silvery 0.17.3 → 0.18.0

package/dist/theme.d.mts

@@ -1,5 +1,5 @@
-import { $ as detectTheme, A as everforestDark, At as HueName, B as oneDark, C as ayuMirage, Ct as ThemeContext, D as snazzy, Dt as AnsiPrimary, E as materialLight, Et as useTheme, F as rosePine, G as solarizedLight, H as tokyoNightDay, I as rosePineDawn, J as catppuccinFrappe, K as dracula, L as rosePineMoon, M as kanagawaDragon, Mt as AnsiColorName, N as kanagawaLotus, O as monokai, Ot as COLOR_PALETTE_FIELDS, P as kanagawaWave, Q as DetectThemeOptions, R as gruvboxDark, S as ayuLight, St as generateTheme, T as materialDark, Tt as ThemeProviderProps, U as tokyoNightStorm, V as tokyoNight, W as solarizedDark, X as catppuccinMacchiato, Y as catppuccinLatte, Z as catppuccinMocha, _ as moonfly, _t as fromColors, a as defaultDarkTheme, at as resolveAliases, b as nightfox, bt as presetTheme, c as getThemeByName, ct as ThemeValidationResult, d as edgeDark, dt as validateColorPalette, et as exportBase16, f as edgeLight, ft as getActiveTheme, g as nightfly, gt as fromBase16, h as oxocarbonLight, ht as setActiveTheme, i as builtinThemes, it as themeToCSSVars, j as everforestLight, jt as Theme, k as monokaiPro, kt as ColorPalette, l as modusOperandi, lt as validateTheme, m as oxocarbonDark, mt as pushContextTheme, n as ansi16LightTheme, nt as Base16Scheme, o as defaultLightTheme, ot as resolveTokenAlias, p as sonokai, pt as popContextTheme, q as nord, r as builtinPalettes, rt as autoGenerateTheme, s as getPaletteByName, st as THEME_TOKEN_KEYS, t as ansi16DarkTheme, tt as importBase16, u as modusVivendi, ut as ValidationResult, v as horizon, vt as fromPreset, w as palenight, wt as ThemeProvider, x as ayuDark, xt as quickTheme, y as dawnfox, yt as createTheme, z as gruvboxLight } from "./index-DCVL3jHo.mjs";
-import { n as deriveTheme, r as resolveThemeColor, t as ThemeAdjustment } from "./derive-D7bFJdfU.mjs";
+import { $ as detectTheme, A as everforestDark, At as AnsiPrimary, B as oneDark, C as ayuMirage, Ct as presetTheme, D as snazzy, Dt as ThemeProvider, E as materialLight, Et as ThemeContext, F as rosePine, Ft as AnsiColorName, G as solarizedLight, H as tokyoNightDay, I as rosePineDawn, J as catppuccinFrappe, K as dracula, L as rosePineMoon, M as kanagawaDragon, Mt as ColorScheme, N as kanagawaLotus, Nt as HueName, O as monokai, Ot as ThemeProviderProps, P as kanagawaWave, Pt as Theme, Q as DetectThemeOptions, R as gruvboxDark, S as ayuLight, St as createTheme, T as materialDark, Tt as generateTheme, U as tokyoNightStorm, V as tokyoNight, W as solarizedDark, X as catppuccinMacchiato, Y as catppuccinLatte, Z as catppuccinMocha, _ as moonfly, _t as setActiveColorLevel, a as defaultDarkTheme, at as resolveAliases, b as nightfox, bt as fromColors, c as getThemeByName, ct as ThemeValidationResult, d as edgeDark, dt as validateColorScheme, et as exportBase16, f as edgeLight, ft as ActiveColorLevel, g as nightfly, gt as pushContextTheme, h as oxocarbonLight, ht as popContextTheme, i as builtinThemes, it as themeToCSSVars, j as everforestLight, jt as COLOR_SCHEME_FIELDS, k as monokaiPro, kt as useTheme, l as modusOperandi, lt as validateTheme, m as oxocarbonDark, mt as getActiveTheme, n as ansi16LightTheme, nt as Base16Scheme, o as defaultLightTheme, ot as resolveTokenAlias, p as sonokai, pt as getActiveColorLevel, q as nord, r as builtinPalettes, rt as autoGenerateTheme, s as getSchemeByName, st as THEME_TOKEN_KEYS, t as ansi16DarkTheme, tt as importBase16, u as modusVivendi, ut as ValidationResult, v as horizon, vt as setActiveTheme, w as palenight, wt as quickTheme, x as ayuDark, xt as fromPreset, y as dawnfox, yt as fromBase16, z as gruvboxLight } from "./index-dehZ18K-.mjs";
+import { n as deriveTheme, r as resolveThemeColor, t as ThemeAdjustment } from "./derive-O_Kb1Bk_.mjs";
 
 //#region packages/color/src/types.d.ts
 /** HSL color: [hue: 0-360, saturation: 0-1, lightness: 0-1] */
@@ -20,39 +20,54 @@ declare function hexToRgb(hex: string): [number, number, number] | null;
 /** Convert [r, g, b] (0-255) to hex string. */
 declare function rgbToHex(r: number, g: number, b: number): string;
 /**
- * Blend two hex colors. t=0 returns a, t=1 returns b.
+ * Blend two hex colors in OKLab space. t=0 returns a, t=1 returns b.
+ * Perceptually-uniform midpoints (unlike naive RGB blending which produces
+ * muddy halfway colors).
+ *
+ * Interpolation is done in OKLab (rectangular a/b), not OKLCH (polar). This
+ * matches CSS Color Module 4's default interpolation space and avoids hue-arc
+ * weirdness when one endpoint is near-neutral (its hue is effectively
+ * undefined). For explicit hue-rotation blending, use `lerpOklch` directly.
+ *
  * For non-hex inputs (ANSI names), returns `a` unchanged.
  */
 declare function blend(a: string, b: string, t: number): string;
 /**
- * Brighten a hex color. amount=0.1 adds 10% lightness toward white.
- * For non-hex inputs (ANSI names), returns the color unchanged.
+ * Brighten a hex color by raising OKLCH lightness. amount=0.1 adds 0.1 to L
+ * (perceptually linear — 10% brighter looks 10% brighter regardless of hue).
+ *
+ * For non-hex inputs, returns the color unchanged.
  */
 declare function brighten(color: string, amount: number): string;
 /**
- * Darken a hex color. amount=0.1 adds 10% darkness toward black.
- * For non-hex inputs (ANSI names), returns the color unchanged.
+ * Darken a hex color by lowering OKLCH lightness. amount=0.1 subtracts 0.1 from L.
+ *
+ * For non-hex inputs, returns the color unchanged.
  */
 declare function darken(color: string, amount: number): string;
 /**
- * Pick black or white text for readability on the given background.
- * Uses relative luminance (WCAG formula).
- */
-declare function contrastFg(bg: string): "#000000" | "#FFFFFF";
-declare function rgbToHsl(r: number, g: number, b: number): HSL;
-declare function hslToHex(h: number, s: number, l: number): string;
-declare function hexToHsl(hex: string): HSL | null;
-/**
- * Desaturate a hex color by reducing saturation.
- * amount=0.4 reduces saturation by 40%.
+ * Desaturate a hex color by lowering OKLCH chroma. amount=0.4 reduces C by 40%
+ * (relative — consistent with the original HSL-based contract). For a flat
+ * subtraction, use `saturate(color, -amount)`.
+ *
  * For non-hex inputs, returns the color unchanged.
  */
 declare function desaturate(color: string, amount: number): string;
 /**
- * Get the complementary color (180° hue rotation).
+ * Get the complementary color (180° hue rotation) in OKLCH. Preserves L + C,
+ * so the complement has the same perceived brightness and colorfulness.
+ *
  * For non-hex inputs, returns the color unchanged.
  */
 declare function complement(color: string): string;
+/**
+ * Pick black or white text for readability on the given background.
+ * Uses WCAG 2.1 relative luminance.
+ */
+declare function contrastFg(bg: string): "#000000" | "#FFFFFF";
+declare function rgbToHsl(r: number, g: number, b: number): HSL;
+declare function hslToHex(h: number, s: number, l: number): string;
+declare function hexToHsl(hex: string): HSL | null;
 //#endregion
 //#region packages/color/src/contrast.d.ts
 /**
@@ -76,24 +91,24 @@ declare function complement(color: string): string;
  */
 declare function checkContrast(fg: string, bg: string): ContrastResult | null;
 /**
- * Adjust a color's lightness until it meets a minimum contrast ratio
- * against a reference color. Preserves hue and saturation — only
- * lightness is shifted, and only as much as needed.
+ * Adjust a color's OKLCH lightness until it meets a minimum WCAG contrast ratio
+ * against a reference color. Preserves hue and chroma — only lightness shifts,
+ * and only as much as needed.
  *
  * Returns the original color unchanged if it already meets the target.
  *
+ * For impossible targets (e.g. 21:1 against mid-gray), returns the
+ * best achievable color (near-black or near-white in the same hue).
+ *
  * @param color - The color to adjust (hex)
  * @param against - The reference background color (hex)
  * @param minRatio - Minimum contrast ratio to achieve (e.g. 4.5 for AA)
  * @returns Adjusted hex color meeting the target, or original if already OK
  *
- * For impossible targets (e.g. 21:1 against mid-gray), returns the
- * best achievable color (near-black or near-white in the same hue).
- *
  * @example
  * ```typescript
- * // Yellow on white — too low contrast, gets darkened
- * ensureContrast("#FFAB91", "#FFFFFF", 4.5)  // → "#B35600" (darker orange)
+ * // Yellow on white — too low contrast, gets darkened (perceptually; same hue preserved)
+ * ensureContrast("#FFAB91", "#FFFFFF", 4.5)
  *
  * // Blue on dark bg — already fine, returned unchanged
  * ensureContrast("#5C9FFF", "#1A1A2E", 4.5)  // → "#5C9FFF"
@@ -102,14 +117,14 @@ declare function checkContrast(fg: string, bg: string): ContrastResult | null;
 declare function ensureContrast(color: string, against: string, minRatio: number): string;
 //#endregion
 //#region packages/ansi/src/theme/detect.d.ts
-interface DetectedPalette {
+interface DetectedScheme {
   fg: string | null;
   bg: string | null;
   ansi: (string | null)[];
   dark: boolean;
-  palette: Partial<ColorPalette>;
+  palette: Partial<ColorScheme>;
 }
-declare function detectTerminalPalette(timeoutMs?: number): Promise<DetectedPalette | null>;
+declare function detectTerminalScheme(timeoutMs?: number): Promise<DetectedScheme | null>;
 //#endregion
-export { AnsiColorName, AnsiPrimary, Base16Scheme, COLOR_PALETTE_FIELDS, ColorPalette, ContrastResult, DetectThemeOptions, DetectedPalette, HSL, HueName, THEME_TOKEN_KEYS, Theme, ThemeAdjustment, ThemeContext, ThemeProvider, ThemeProviderProps, ThemeValidationResult, ValidationResult, ansi16DarkTheme, ansi16LightTheme, autoGenerateTheme, ayuDark, ayuLight, ayuMirage, blend, brighten, builtinPalettes, builtinThemes, catppuccinFrappe, catppuccinLatte, catppuccinMacchiato, catppuccinMocha, checkContrast, complement, contrastFg, createTheme, darken, dawnfox, defaultDarkTheme, defaultLightTheme, deriveTheme, desaturate, detectTerminalPalette, detectTheme, dracula, edgeDark, edgeLight, ensureContrast, everforestDark, everforestLight, exportBase16, fromBase16, fromColors, fromPreset, generateTheme, getActiveTheme, getPaletteByName, getThemeByName, gruvboxDark, gruvboxLight, hexToHsl, hexToRgb, horizon, hslToHex, importBase16, kanagawaDragon, kanagawaLotus, kanagawaWave, materialDark, materialLight, modusOperandi, modusVivendi, monokai, monokaiPro, moonfly, nightfly, nightfox, nord, oneDark, oxocarbonDark, oxocarbonLight, palenight, popContextTheme, presetTheme, pushContextTheme, quickTheme, resolveAliases, resolveThemeColor, resolveTokenAlias, rgbToHex, rgbToHsl, rosePine, rosePineDawn, rosePineMoon, setActiveTheme, snazzy, solarizedDark, solarizedLight, sonokai, themeToCSSVars, tokyoNight, tokyoNightDay, tokyoNightStorm, useTheme, validateColorPalette, validateTheme };
+export { ActiveColorLevel, AnsiColorName, AnsiPrimary, Base16Scheme, COLOR_SCHEME_FIELDS, ColorScheme, ContrastResult, DetectThemeOptions, DetectedScheme, HSL, HueName, THEME_TOKEN_KEYS, Theme, ThemeAdjustment, ThemeContext, ThemeProvider, ThemeProviderProps, ThemeValidationResult, ValidationResult, ansi16DarkTheme, ansi16LightTheme, autoGenerateTheme, ayuDark, ayuLight, ayuMirage, blend, brighten, builtinPalettes, builtinThemes, catppuccinFrappe, catppuccinLatte, catppuccinMacchiato, catppuccinMocha, checkContrast, complement, contrastFg, createTheme, darken, dawnfox, defaultDarkTheme, defaultLightTheme, deriveTheme, desaturate, detectTerminalScheme, detectTheme, dracula, edgeDark, edgeLight, ensureContrast, everforestDark, everforestLight, exportBase16, fromBase16, fromColors, fromPreset, generateTheme, getActiveColorLevel, getActiveTheme, getSchemeByName, getThemeByName, gruvboxDark, gruvboxLight, hexToHsl, hexToRgb, horizon, hslToHex, importBase16, kanagawaDragon, kanagawaLotus, kanagawaWave, materialDark, materialLight, modusOperandi, modusVivendi, monokai, monokaiPro, moonfly, nightfly, nightfox, nord, oneDark, oxocarbonDark, oxocarbonLight, palenight, popContextTheme, presetTheme, pushContextTheme, quickTheme, resolveAliases, resolveThemeColor, resolveTokenAlias, rgbToHex, rgbToHsl, rosePine, rosePineDawn, rosePineMoon, setActiveColorLevel, setActiveTheme, snazzy, solarizedDark, solarizedLight, sonokai, themeToCSSVars, tokyoNight, tokyoNightDay, tokyoNightStorm, useTheme, validateColorScheme, validateTheme };
 //# sourceMappingURL=theme.d.mts.map

package/dist/theme.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"theme.d.mts","names":[],"sources":["../packages/color/src/types.ts","../packages/color/src/color.ts","../packages/color/src/contrast.ts","../packages/ansi/src/theme/detect.ts"],"mappings":";;;;;KACY,GAAA;;UAGK,cAAA;EAHL;EAKV,KAAA;;EAEA,EAAA;EAPa;EASb,GAAA;AAAA;;;;iBCQc,QAAA,CAAS,GAAA;;iBAaT,QAAA,CAAS,CAAA,UAAW,CAAA,UAAW,CAAA;;;;;iBAa/B,KAAA,CAAM,CAAA,UAAW,CAAA,UAAW,CAAA;;AA1B5C;;;iBA0CgB,QAAA,CAAS,KAAA,UAAe,MAAA;;AA7BxC;;;iBAqCgB,MAAA,CAAO,KAAA,UAAe,MAAA;;;;AARtC;iBAwCgB,UAAA,CAAW,EAAA;AAAA,iBAUX,QAAA,CAAS,CAAA,UAAW,CAAA,UAAW,CAAA,WAAY,GAAA;AAAA,iBAiB3C,QAAA,CAAS,CAAA,UAAW,CAAA,UAAW,CAAA;AAAA,iBAU/B,QAAA,CAAS,GAAA,WAAc,GAAA;AArEvC;;;;;AAAA,iBAgFgB,UAAA,CAAW,KAAA,UAAe,MAAA;;;;;iBAW1B,UAAA,CAAW,KAAA;;;AD3J3B;;;;;;;;;;;;ACcA;;;;;AAaA;;AD3BA,iBE2BgB,aAAA,CAAc,EAAA,UAAY,EAAA,WAAa,cAAA;;;;;;;ADavD;;;;;;;;;AAgBA;;;;;AAQA;;;;iBCGgB,cAAA,CAAe,KAAA,UAAe,OAAA,UAAiB,QAAA;;;UC7D9C,eAAA;EACf,EAAA;EACA,EAAA;EACA,IAAA;EACA,IAAA;EACA,OAAA,EAAS,OAAA,CAAQ,YAAA;AAAA;AAAA,iBAGG,qBAAA,CAAsB,SAAA,YAAkB,OAAA,CAAQ,eAAA"}
+{"version":3,"file":"theme.d.mts","names":[],"sources":["../packages/color/src/types.ts","../packages/color/src/color.ts","../packages/color/src/contrast.ts","../packages/ansi/src/theme/detect.ts"],"mappings":";;;;;KACY,GAAA;;UAGK,cAAA;EAHL;EAKV,KAAA;;EAEA,EAAA;EAPa;EASb,GAAA;AAAA;;;;iBCYc,QAAA,CAAS,GAAA;;iBAaT,QAAA,CAAS,CAAA,UAAW,CAAA,UAAW,CAAA;;;;;AAA/C;;;;;;;;iBAmCgB,KAAA,CAAM,CAAA,UAAW,CAAA,UAAW,CAAA;AAA5C;;;;;;AAAA,iBAUgB,QAAA,CAAS,KAAA,UAAe,MAAA;;;AAAxC;;;iBAWgB,MAAA,CAAO,KAAA,UAAe,MAAA;;;;;AAqCtC;;;iBAZgB,UAAA,CAAW,KAAA,UAAe,MAAA;;AAqD1C;;;;;iBAzCgB,UAAA,CAAW,KAAA;;;;;iBAyCX,UAAA,CAAW,EAAA;AAAA,iBAUX,QAAA,CAAS,CAAA,UAAW,CAAA,UAAW,CAAA,WAAY,GAAA;AAAA,iBAiB3C,QAAA,CAAS,CAAA,UAAW,CAAA,UAAW,CAAA;AAAA,iBAU/B,QAAA,CAAS,GAAA,WAAc,GAAA;;;;;;;;;;;;;AAxLvC;;;;;AAaA;;;;iBCDgB,aAAA,CAAc,EAAA,UAAY,EAAA,WAAa,cAAA;;;;;ADoCvD;;;;;;;;;AAUA;;;;;AAWA;;;;;AAyBA;iBC1CgB,cAAA,CAAe,KAAA,UAAe,OAAA,UAAiB,QAAA;;;UChE9C,cAAA;EACf,EAAA;EACA,EAAA;EACA,IAAA;EACA,IAAA;EACA,OAAA,EAAS,OAAA,CAAQ,WAAA;AAAA;AAAA,iBAGG,oBAAA,CAAqB,SAAA,YAAkB,OAAA,CAAQ,cAAA"}

package/dist/theme.mjs

@@ -1,8 +1,8 @@
-import { A as contrastFg, C as resolveThemeColor, D as blend, E as ensureContrast, F as hslToHex, I as rgbToHex, L as rgbToHsl, M as desaturate, N as hexToHsl, O as brighten, P as hexToRgb, T as checkContrast, _ as COLOR_PALETTE_FIELDS, b as deriveTheme, j as darken, k as complement, n as detectTerminalPalette } from "./src-9B5k0JmY.mjs";
-import { $ as ayuMirage, A as setActiveTheme, B as modusVivendi, C as ThemeProvider, Ct as nord, Dt as catppuccinMocha, E as getActiveTheme, Et as catppuccinMacchiato, F as defaultDarkTheme, G as oxocarbonLight, H as edgeLight, I as defaultLightTheme, J as horizon, K as nightfly, L as getPaletteByName, M as ansi16LightTheme, N as builtinPalettes, O as popContextTheme, P as builtinThemes, Q as ayuLight, R as getThemeByName, S as ThemeContext, St as dracula, T as useTheme, Tt as catppuccinLatte, U as sonokai, V as edgeDark, W as oxocarbonDark, X as nightfox, Y as dawnfox, Z as ayuDark, _ as fromColors, _t as tokyoNight, a as exportBase16, at as monokaiPro, b as generateTheme, bt as solarizedDark, c as resolveAliases, ct as kanagawaDragon, d as validateTheme, dt as rosePine, et as palenight, f as validateColorPalette, ft as rosePineDawn, g as fromBase16, gt as oneDark, h as quickTheme, ht as gruvboxLight, it as monokai, j as ansi16DarkTheme, k as pushContextTheme, l as resolveTokenAlias, lt as kanagawaLotus, m as presetTheme, mt as gruvboxDark, nt as materialLight, o as autoGenerateTheme, ot as everforestDark, p as createTheme, pt as rosePineMoon, q as moonfly, r as detectTheme, rt as snazzy, s as themeToCSSVars, st as everforestLight, t as init_src, tt as materialDark, u as THEME_TOKEN_KEYS, ut as kanagawaWave, v as fromPreset, vt as tokyoNightDay, wt as catppuccinFrappe, xt as solarizedLight, y as importBase16, yt as tokyoNightStorm, z as modusOperandi } from "./src-C9f3hiVG.mjs";
+import { A as brighten, B as rgbToHsl, D as checkContrast, F as hexToHsl, I as hexToRgb, L as hslToHex, M as contrastFg, N as darken, O as ensureContrast, P as desaturate, S as deriveTheme, T as resolveThemeColor, b as COLOR_SCHEME_FIELDS, j as complement, k as blend, r as detectTerminalScheme, z as rgbToHex } from "./src-D_BS-as7.mjs";
+import { $ as ayuDark, A as pushContextTheme, B as getThemeByName, C as ThemeProvider, Ct as solarizedLight, D as getActiveTheme, Dt as catppuccinLatte, E as getActiveColorLevel, Et as catppuccinFrappe, F as builtinPalettes, G as sonokai, H as modusVivendi, I as builtinThemes, J as nightfly, K as oxocarbonDark, L as defaultDarkTheme, M as setActiveTheme, N as ansi16DarkTheme, Ot as catppuccinMacchiato, P as ansi16LightTheme, Q as nightfox, R as defaultLightTheme, S as ThemeContext, St as solarizedDark, T as useTheme, Tt as nord, U as edgeDark, V as modusOperandi, W as edgeLight, X as horizon, Y as moonfly, Z as dawnfox, _ as fromColors, _t as gruvboxLight, a as exportBase16, at as snazzy, b as generateTheme, bt as tokyoNightDay, c as resolveAliases, ct as everforestDark, d as validateTheme, dt as kanagawaLotus, et as ayuLight, f as validateColorScheme, ft as kanagawaWave, g as fromBase16, gt as gruvboxDark, h as quickTheme, ht as rosePineMoon, it as materialLight, j as setActiveColorLevel, k as popContextTheme, kt as catppuccinMocha, l as resolveTokenAlias, lt as everforestLight, m as presetTheme, mt as rosePineDawn, nt as palenight, o as autoGenerateTheme, ot as monokai, p as createTheme, pt as rosePine, q as oxocarbonLight, r as detectTheme, rt as materialDark, s as themeToCSSVars, st as monokaiPro, t as init_src, tt as ayuMirage, u as THEME_TOKEN_KEYS, ut as kanagawaDragon, v as fromPreset, vt as oneDark, wt as dracula, xt as tokyoNightStorm, y as importBase16, yt as tokyoNight, z as getSchemeByName } from "./src-C0sOQW-t.mjs";
 //#region src/theme.ts
 init_src();
 //#endregion
-export { COLOR_PALETTE_FIELDS, THEME_TOKEN_KEYS, ThemeContext, ThemeProvider, ansi16DarkTheme, ansi16LightTheme, autoGenerateTheme, ayuDark, ayuLight, ayuMirage, blend, brighten, builtinPalettes, builtinThemes, catppuccinFrappe, catppuccinLatte, catppuccinMacchiato, catppuccinMocha, checkContrast, complement, contrastFg, createTheme, darken, dawnfox, defaultDarkTheme, defaultLightTheme, deriveTheme, desaturate, detectTerminalPalette, detectTheme, dracula, edgeDark, edgeLight, ensureContrast, everforestDark, everforestLight, exportBase16, fromBase16, fromColors, fromPreset, generateTheme, getActiveTheme, getPaletteByName, getThemeByName, gruvboxDark, gruvboxLight, hexToHsl, hexToRgb, horizon, hslToHex, importBase16, kanagawaDragon, kanagawaLotus, kanagawaWave, materialDark, materialLight, modusOperandi, modusVivendi, monokai, monokaiPro, moonfly, nightfly, nightfox, nord, oneDark, oxocarbonDark, oxocarbonLight, palenight, popContextTheme, presetTheme, pushContextTheme, quickTheme, resolveAliases, resolveThemeColor, resolveTokenAlias, rgbToHex, rgbToHsl, rosePine, rosePineDawn, rosePineMoon, setActiveTheme, snazzy, solarizedDark, solarizedLight, sonokai, themeToCSSVars, tokyoNight, tokyoNightDay, tokyoNightStorm, useTheme, validateColorPalette, validateTheme };
+export { COLOR_SCHEME_FIELDS, THEME_TOKEN_KEYS, ThemeContext, ThemeProvider, ansi16DarkTheme, ansi16LightTheme, autoGenerateTheme, ayuDark, ayuLight, ayuMirage, blend, brighten, builtinPalettes, builtinThemes, catppuccinFrappe, catppuccinLatte, catppuccinMacchiato, catppuccinMocha, checkContrast, complement, contrastFg, createTheme, darken, dawnfox, defaultDarkTheme, defaultLightTheme, deriveTheme, desaturate, detectTerminalScheme, detectTheme, dracula, edgeDark, edgeLight, ensureContrast, everforestDark, everforestLight, exportBase16, fromBase16, fromColors, fromPreset, generateTheme, getActiveColorLevel, getActiveTheme, getSchemeByName, getThemeByName, gruvboxDark, gruvboxLight, hexToHsl, hexToRgb, horizon, hslToHex, importBase16, kanagawaDragon, kanagawaLotus, kanagawaWave, materialDark, materialLight, modusOperandi, modusVivendi, monokai, monokaiPro, moonfly, nightfly, nightfox, nord, oneDark, oxocarbonDark, oxocarbonLight, palenight, popContextTheme, presetTheme, pushContextTheme, quickTheme, resolveAliases, resolveThemeColor, resolveTokenAlias, rgbToHex, rgbToHsl, rosePine, rosePineDawn, rosePineMoon, setActiveColorLevel, setActiveTheme, snazzy, solarizedDark, solarizedLight, sonokai, themeToCSSVars, tokyoNight, tokyoNightDay, tokyoNightStorm, useTheme, validateColorScheme, validateTheme };
 
 //# sourceMappingURL=theme.mjs.map

package/dist/{types-CDgkE-Rw.d.mts → types-B4A8Ebba.d.mts}

@@ -238,4 +238,4 @@ interface WithSelectOptions {
 }
 //#endregion
 export { TextInputOptions as _, ProgressInfo as a, WithSelectOptions as b, SpinnerOptions as c, StepProgress as d, TableColumn as f, TaskStatus as g, TaskState as h, ProgressGenerator as i, SpinnerProps as l, TaskProps as m, ProgressBarProps as n, SelectOption as o, TableProps as p, ProgressCallback as r, SelectProps as s, ProgressBarOptions as t, SpinnerStyle as u, TextInputProps as v, WithSpinnerOptions as x, WithProgressOptions as y };
-//# sourceMappingURL=types-CDgkE-Rw.d.mts.map
+//# sourceMappingURL=types-B4A8Ebba.d.mts.map

package/dist/{types-CDgkE-Rw.d.mts.map → types-B4A8Ebba.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"types-CDgkE-Rw.d.mts","names":[],"sources":["../packages/ag-react/src/ui/types.ts"],"mappings":"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"}
+{"version":3,"file":"types-B4A8Ebba.d.mts","names":[],"sources":["../packages/ag-react/src/ui/types.ts"],"mappings":"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"}

package/dist/types-e4dpfbSa.mjs

@@ -0,0 +1,468 @@
+//#region ../../node_modules/.bun/alien-signals@3.1.2/node_modules/alien-signals/esm/system.mjs
+function createReactiveSystem({ update, notify, unwatched }) {
+	return {
+		link,
+		unlink,
+		propagate,
+		checkDirty,
+		shallowPropagate
+	};
+	function link(dep, sub, version) {
+		const prevDep = sub.depsTail;
+		if (prevDep !== void 0 && prevDep.dep === dep) return;
+		const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
+		if (nextDep !== void 0 && nextDep.dep === dep) {
+			nextDep.version = version;
+			sub.depsTail = nextDep;
+			return;
+		}
+		const prevSub = dep.subsTail;
+		if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) return;
+		const newLink = sub.depsTail = dep.subsTail = {
+			version,
+			dep,
+			sub,
+			prevDep,
+			nextDep,
+			prevSub,
+			nextSub: void 0
+		};
+		if (nextDep !== void 0) nextDep.prevDep = newLink;
+		if (prevDep !== void 0) prevDep.nextDep = newLink;
+		else sub.deps = newLink;
+		if (prevSub !== void 0) prevSub.nextSub = newLink;
+		else dep.subs = newLink;
+	}
+	function unlink(link, sub = link.sub) {
+		const dep = link.dep;
+		const prevDep = link.prevDep;
+		const nextDep = link.nextDep;
+		const nextSub = link.nextSub;
+		const prevSub = link.prevSub;
+		if (nextDep !== void 0) nextDep.prevDep = prevDep;
+		else sub.depsTail = prevDep;
+		if (prevDep !== void 0) prevDep.nextDep = nextDep;
+		else sub.deps = nextDep;
+		if (nextSub !== void 0) nextSub.prevSub = prevSub;
+		else dep.subsTail = prevSub;
+		if (prevSub !== void 0) prevSub.nextSub = nextSub;
+		else if ((dep.subs = nextSub) === void 0) unwatched(dep);
+		return nextDep;
+	}
+	function propagate(link) {
+		let next = link.nextSub;
+		let stack;
+		top: do {
+			const sub = link.sub;
+			let flags = sub.flags;
+			if (!(flags & 60)) sub.flags = flags | 32;
+			else if (!(flags & 12)) flags = 0;
+			else if (!(flags & 4)) sub.flags = flags & -9 | 32;
+			else if (!(flags & 48) && isValidLink(link, sub)) {
+				sub.flags = flags | 40;
+				flags &= 1;
+			} else flags = 0;
+			if (flags & 2) notify(sub);
+			if (flags & 1) {
+				const subSubs = sub.subs;
+				if (subSubs !== void 0) {
+					const nextSub = (link = subSubs).nextSub;
+					if (nextSub !== void 0) {
+						stack = {
+							value: next,
+							prev: stack
+						};
+						next = nextSub;
+					}
+					continue;
+				}
+			}
+			if ((link = next) !== void 0) {
+				next = link.nextSub;
+				continue;
+			}
+			while (stack !== void 0) {
+				link = stack.value;
+				stack = stack.prev;
+				if (link !== void 0) {
+					next = link.nextSub;
+					continue top;
+				}
+			}
+			break;
+		} while (true);
+	}
+	function checkDirty(link, sub) {
+		let stack;
+		let checkDepth = 0;
+		let dirty = false;
+		top: do {
+			const dep = link.dep;
+			const flags = dep.flags;
+			if (sub.flags & 16) dirty = true;
+			else if ((flags & 17) === 17) {
+				if (update(dep)) {
+					const subs = dep.subs;
+					if (subs.nextSub !== void 0) shallowPropagate(subs);
+					dirty = true;
+				}
+			} else if ((flags & 33) === 33) {
+				if (link.nextSub !== void 0 || link.prevSub !== void 0) stack = {
+					value: link,
+					prev: stack
+				};
+				link = dep.deps;
+				sub = dep;
+				++checkDepth;
+				continue;
+			}
+			if (!dirty) {
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue;
+				}
+			}
+			while (checkDepth--) {
+				const firstSub = sub.subs;
+				const hasMultipleSubs = firstSub.nextSub !== void 0;
+				if (hasMultipleSubs) {
+					link = stack.value;
+					stack = stack.prev;
+				} else link = firstSub;
+				if (dirty) {
+					if (update(sub)) {
+						if (hasMultipleSubs) shallowPropagate(firstSub);
+						sub = link.sub;
+						continue;
+					}
+					dirty = false;
+				} else sub.flags &= -33;
+				sub = link.sub;
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue top;
+				}
+			}
+			return dirty;
+		} while (true);
+	}
+	function shallowPropagate(link) {
+		do {
+			const sub = link.sub;
+			const flags = sub.flags;
+			if ((flags & 48) === 32) {
+				sub.flags = flags | 16;
+				if ((flags & 6) === 2) notify(sub);
+			}
+		} while ((link = link.nextSub) !== void 0);
+	}
+	function isValidLink(checkLink, sub) {
+		let link = sub.depsTail;
+		while (link !== void 0) {
+			if (link === checkLink) return true;
+			link = link.prevDep;
+		}
+		return false;
+	}
+}
+//#endregion
+//#region ../../node_modules/.bun/alien-signals@3.1.2/node_modules/alien-signals/esm/index.mjs
+let cycle = 0;
+let notifyIndex = 0;
+let queuedLength = 0;
+let activeSub;
+const queued = [];
+const { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
+	update(node) {
+		if (node.depsTail !== void 0) return updateComputed(node);
+		else return updateSignal(node);
+	},
+	notify(effect) {
+		let insertIndex = queuedLength;
+		let firstInsertedIndex = insertIndex;
+		do {
+			queued[insertIndex++] = effect;
+			effect.flags &= -3;
+			effect = effect.subs?.sub;
+			if (effect === void 0 || !(effect.flags & 2)) break;
+		} while (true);
+		queuedLength = insertIndex;
+		while (firstInsertedIndex < --insertIndex) {
+			const left = queued[firstInsertedIndex];
+			queued[firstInsertedIndex++] = queued[insertIndex];
+			queued[insertIndex] = left;
+		}
+	},
+	unwatched(node) {
+		if (!(node.flags & 1)) effectScopeOper.call(node);
+		else if (node.depsTail !== void 0) {
+			node.depsTail = void 0;
+			node.flags = 17;
+			purgeDeps(node);
+		}
+	}
+});
+function setActiveSub(sub) {
+	const prevSub = activeSub;
+	activeSub = sub;
+	return prevSub;
+}
+function signal(initialValue) {
+	return signalOper.bind({
+		currentValue: initialValue,
+		pendingValue: initialValue,
+		subs: void 0,
+		subsTail: void 0,
+		flags: 1
+	});
+}
+function computed(getter) {
+	return computedOper.bind({
+		value: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: 0,
+		getter
+	});
+}
+function effect(fn) {
+	const e = {
+		fn,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: 6
+	};
+	const prevSub = setActiveSub(e);
+	if (prevSub !== void 0) link(e, prevSub, 0);
+	try {
+		e.fn();
+	} finally {
+		activeSub = prevSub;
+		e.flags &= -5;
+	}
+	return effectOper.bind(e);
+}
+function updateComputed(c) {
+	++cycle;
+	c.depsTail = void 0;
+	c.flags = 5;
+	const prevSub = setActiveSub(c);
+	try {
+		const oldValue = c.value;
+		return oldValue !== (c.value = c.getter(oldValue));
+	} finally {
+		activeSub = prevSub;
+		c.flags &= -5;
+		purgeDeps(c);
+	}
+}
+function updateSignal(s) {
+	s.flags = 1;
+	return s.currentValue !== (s.currentValue = s.pendingValue);
+}
+function run(e) {
+	const flags = e.flags;
+	if (flags & 16 || flags & 32 && checkDirty(e.deps, e)) {
+		++cycle;
+		e.depsTail = void 0;
+		e.flags = 6;
+		const prevSub = setActiveSub(e);
+		try {
+			e.fn();
+		} finally {
+			activeSub = prevSub;
+			e.flags &= -5;
+			purgeDeps(e);
+		}
+	} else e.flags = 2;
+}
+function flush() {
+	try {
+		while (notifyIndex < queuedLength) {
+			const effect = queued[notifyIndex];
+			queued[notifyIndex++] = void 0;
+			run(effect);
+		}
+	} finally {
+		while (notifyIndex < queuedLength) {
+			const effect = queued[notifyIndex];
+			queued[notifyIndex++] = void 0;
+			effect.flags |= 10;
+		}
+		notifyIndex = 0;
+		queuedLength = 0;
+	}
+}
+function computedOper() {
+	const flags = this.flags;
+	if (flags & 16 || flags & 32 && (checkDirty(this.deps, this) || (this.flags = flags & -33, false))) {
+		if (updateComputed(this)) {
+			const subs = this.subs;
+			if (subs !== void 0) shallowPropagate(subs);
+		}
+	} else if (!flags) {
+		this.flags = 5;
+		const prevSub = setActiveSub(this);
+		try {
+			this.value = this.getter();
+		} finally {
+			activeSub = prevSub;
+			this.flags &= -5;
+		}
+	}
+	const sub = activeSub;
+	if (sub !== void 0) link(this, sub, cycle);
+	return this.value;
+}
+function signalOper(...value) {
+	if (value.length) {
+		if (this.pendingValue !== (this.pendingValue = value[0])) {
+			this.flags = 17;
+			const subs = this.subs;
+			if (subs !== void 0) {
+				propagate(subs);
+				flush();
+			}
+		}
+	} else {
+		if (this.flags & 16) {
+			if (updateSignal(this)) {
+				const subs = this.subs;
+				if (subs !== void 0) shallowPropagate(subs);
+			}
+		}
+		let sub = activeSub;
+		while (sub !== void 0) {
+			if (sub.flags & 3) {
+				link(this, sub, cycle);
+				break;
+			}
+			sub = sub.subs?.sub;
+		}
+		return this.currentValue;
+	}
+}
+function effectOper() {
+	effectScopeOper.call(this);
+}
+function effectScopeOper() {
+	this.depsTail = void 0;
+	this.flags = 0;
+	purgeDeps(this);
+	const sub = this.subs;
+	if (sub !== void 0) unlink(sub);
+}
+function purgeDeps(sub) {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink(dep, sub);
+}
+//#endregion
+//#region packages/ag/src/layout-signals.ts
+/**
+* withLayoutSignals — reactive signal layer for AgNode layout outputs.
+*
+* Composable plugin that wraps an AgNode with reactive signals for layout
+* rects, text content, and focus state. Engine-agnostic — works with
+* Flexily, Yoga, or any future layout engine.
+*
+* Signals are WeakMap-backed and lazily created. Nodes without subscribers
+* pay zero cost. After layout completes, the pipeline calls `syncSignals()`
+* to propagate imperative state into signals.
+*
+* ## Usage
+*
+* ```ts
+* import { getLayoutSignals, syncSignals } from "@silvery/ag/layout-signals"
+*
+* // Get (or create) signals for a node
+* const signals = getLayoutSignals(node)
+* signals.boxRect()       // read current rect
+* signals.textContent()   // read current text
+*
+* // After layout/reconciler mutations, sync imperative → reactive
+* syncSignals(node)
+* ```
+*
+* ## Three-layer stack
+*
+* Layer 0: alien-signals (signal, computed, effect)
+* Layer 1: getLayoutSignals() — this module (@silvery/ag, framework-agnostic)
+* Layer 2: useSignal(signal) — @silvery/ag-react (React bridge)
+* Layer 3: useBoxRect(), useAgNode() — semantic convenience hooks
+*/
+const signalMap = /* @__PURE__ */ new WeakMap();
+/**
+* Get or create layout signals for a node.
+*
+* Lazily created on first access. Automatically garbage-collected
+* when the node is removed from the tree (WeakMap semantics).
+*/
+function getLayoutSignals(node) {
+	let s = signalMap.get(node);
+	if (!s) {
+		s = {
+			boxRect: signal(node.boxRect),
+			scrollRect: signal(node.scrollRect),
+			screenRect: signal(node.screenRect),
+			textContent: signal(node.textContent),
+			focused: signal(node.interactiveState?.focused ?? false)
+		};
+		signalMap.set(node, s);
+	}
+	return s;
+}
+/**
+* Sync all rect signals from the node's current values.
+*
+* Called from notifyLayoutSubscribers after layout + scroll + sticky
+* phases complete. Only syncs nodes that have signals allocated.
+* Reference-equality check prevents unnecessary downstream updates.
+*/
+function syncRectSignals(node) {
+	const s = signalMap.get(node);
+	if (!s) return;
+	if (node.boxRect !== s.boxRect()) s.boxRect(node.boxRect);
+	if (node.scrollRect !== s.scrollRect()) s.scrollRect(node.scrollRect);
+	if (node.screenRect !== s.screenRect()) s.screenRect(node.screenRect);
+}
+/**
+* Sync textContent signal from the node's current value.
+*
+* Called from commitTextUpdate in the reconciler.
+*/
+function syncTextContentSignal(node) {
+	const s = signalMap.get(node);
+	if (!s) return;
+	if (node.textContent !== s.textContent()) s.textContent(node.textContent);
+}
+/**
+* Sync focused signal for a node.
+*
+* Called from FocusManager when focus changes.
+*/
+function syncFocusedSignal(node, focused) {
+	const s = signalMap.get(node);
+	if (!s) return;
+	if (focused !== s.focused()) s.focused(focused);
+}
+//#endregion
+//#region packages/ag/src/types.ts
+/**
+* Check if two rects are equal (same position and size).
+*/
+function rectEqual(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+//#endregion
+export { syncTextContentSignal as a, signal as c, syncRectSignals as i, getLayoutSignals as n, computed as o, syncFocusedSignal as r, effect as s, rectEqual as t };
+
+//# sourceMappingURL=types-e4dpfbSa.mjs.map