@cube-dev/ui-kit 0.0.0-canary-7464463 → 0.0.0-canary-a5d43c3

package/dist/tokens/color-theme.d.ts

@@ -0,0 +1,86 @@
+
+import { Styles } from "@tenphi/tasty";
+import { ColorMap } from "@tenphi/glaze";
+
+//#region src/tokens/color-theme.d.ts
+interface ColorThemeConfig {
+  /**
+   * A hue in 0–360, or any colour Glaze parses — hex, `rgb()`, `hsl()`,
+   * `okhsl()`, `okhst()`, `oklch()`.
+   *
+   * From a colour only the HUE and SATURATION are taken; the lightness is
+   * discarded and re-derived per scheme. That is what makes the result adaptive
+   * rather than a value that happens to work in one theme.
+   */
+  hue: number | string;
+  /** 0–100. @default the palette's own saturation seed */
+  saturation?: number;
+  pastel?: boolean;
+  /**
+   * Extra colour definitions, merged over {@link TINT_RECIPE}. Anything Glaze's
+   * `theme.colors()` accepts, including `contrast` floors against a sibling.
+   */
+  colors?: ColorMap;
+}
+interface ColorTheme {
+  /**
+   * A hash of the config, and the token prefix — `'tint-1a2b3c'`.
+   *
+   * Content-addressed rather than positional so two components asking for the
+   * same colour name the same theme, and therefore share one injection. Also
+   * makes it safe to stamp on the DOM as an identifier.
+   */
+  name: string;
+  /**
+   * Tasty token declarations, one state map per colour:
+   * `{ '#tint-1a2b3c-surface': { '': …, '@dark': …, '@hc': …, '@dark & @hc': … } }`
+   */
+  tokens: Styles;
+  /** Token references by their unprefixed name — `{ surface: '#tint-1a2b3c-surface' }`. */
+  colors: Record<string, string>;
+}
+/**
+ * The hue and saturation of a colour, for use as a theme seed.
+ *
+ * ```ts
+ * colorThemeSeed('#0ea5e9'); // → { hue: 237.32, saturation: 98.19 }
+ * ```
+ */
+declare function colorThemeSeed(value: string): {
+  hue: number;
+  saturation: number;
+};
+/**
+ * Build (or reuse) an adaptive theme from a hue.
+ *
+ * Pure and memoized: the same config returns the same object identity until the
+ * palette is re-seeded. Registering the tokens is {@link useColorTheme}'s job —
+ * this only computes them, so it is safe to call while rendering or from a test.
+ */
+declare function getColorTheme(config: ColorThemeConfig): ColorTheme;
+/**
+ * Register an adaptive theme's tokens once per document, and get it back.
+ *
+ * The tokens land on `body` under a slot keyed by the theme's name, which is a
+ * hash of the config — so every component asking for the same colour shares one
+ * injection no matter how many of them there are. Tasty's global-style slots are
+ * also permanent, which is what makes that safe: one component unmounting cannot
+ * strip tokens another is still referencing.
+ *
+ * `body` rather than `:root`, which emits nothing at all — the same selector
+ * `GlobalStyles` uses for the palette's own tokens. Custom properties inherit, so
+ * anything rendered inside the document sees them; the one thing this cannot
+ * reach is content portalled outside `<body>`, which nothing does.
+ *
+ * Because the slot id hashes the CONFIG rather than the resolved values,
+ * re-seeding the palette replaces the same slot instead of leaking a new one.
+ *
+ * ```tsx
+ * const theme = useColorTheme({ hue: '#0ea5e9' });
+ * // theme.colors.surface → '#tint-1a2b3c-surface'
+ * ```
+ */
+declare function useColorTheme(config: ColorThemeConfig): ColorTheme;
+//#endregion
+export { ColorTheme, ColorThemeConfig, colorThemeSeed, getColorTheme, useColorTheme };
+//# sourceMappingURL=color-theme.d.ts.map

package/dist/tokens/color-theme.js

@@ -0,0 +1,156 @@
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-a5d43c3 | Cube Dev Team */
+import { DEFAULT_SATURATION, getPaletteConfig, getPaletteVersion, usePaletteVersion } from "./palette-config.js";
+import { TINT_RECIPE } from "./palette.js";
+import { useGlobalStyles } from "@tenphi/tasty";
+import { glaze } from "@tenphi/glaze";
+
+//#region src/tokens/color-theme.ts
+/**
+* FNV-1a, base36. Short, stable and dependency-free.
+*
+* These hashes name CSS custom properties and land in DOM attributes, so they
+* have to be deterministic across processes (SSR and the client must agree) and
+* safe as identifiers — but not cryptographic.
+*/
+function hashString(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619) >>> 0;
+	}
+	return hash.toString(36);
+}
+/**
+* Hashes the RESOLVED seed, not the config as written.
+*
+* `{ hue: '#0ea5e9' }` and `{ hue: 237.32, saturation: 98.19 }` are the same
+* colour said two ways; hashing the input would give them two names, two
+* injections and two sets of generated rules. Rounded, because a seed that
+* differs in the twelfth decimal is the same colour to every eye and every
+* renderer — and an unrounded float would defeat the deduplication it is here to
+* provide.
+*/
+function hashSeed(seed) {
+	return `tint-${hashString(JSON.stringify([
+		seed.hue.toFixed(4),
+		seed.saturation.toFixed(4),
+		seed.pastel,
+		seed.colors ? stableStringify(seed.colors) : null
+	]))}`;
+}
+/** Key order must not change the hash, or two identical configs get two slots. */
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+}
+/**
+* The hue and saturation of a colour, for use as a theme seed.
+*
+* ```ts
+* colorThemeSeed('#0ea5e9'); // → { hue: 237.32, saturation: 98.19 }
+* ```
+*/
+function colorThemeSeed(value) {
+	const light = glaze.color(value).resolve().light;
+	return {
+		hue: light.h,
+		saturation: light.s * 100
+	};
+}
+/**
+* Cached by `${paletteVersion}:${name}`.
+*
+* The palette version is in the KEY rather than triggering a clear, so a stale
+* entry is simply unreachable. `lastVersion` still clears the map on a change,
+* or repeated `setPaletteConfig` calls would grow it without bound.
+*/
+const cache = /* @__PURE__ */ new Map();
+let lastVersion = -1;
+/**
+* Build (or reuse) an adaptive theme from a hue.
+*
+* Pure and memoized: the same config returns the same object identity until the
+* palette is re-seeded. Registering the tokens is {@link useColorTheme}'s job —
+* this only computes them, so it is safe to call while rendering or from a test.
+*/
+function getColorTheme(config) {
+	const version = getPaletteVersion();
+	if (version !== lastVersion) {
+		cache.clear();
+		lastVersion = version;
+	}
+	const paletteConfig = getPaletteConfig();
+	const parsed = typeof config.hue === "string" ? colorThemeSeed(config.hue) : null;
+	const seed = {
+		hue: parsed ? parsed.hue : config.hue,
+		saturation: config.saturation ?? parsed?.saturation ?? paletteConfig.saturation ?? DEFAULT_SATURATION,
+		pastel: config.pastel ?? paletteConfig.pastel ?? false,
+		colors: config.colors
+	};
+	const name = hashSeed(seed);
+	const cached = cache.get(name);
+	if (cached) return cached;
+	const { hue, saturation } = seed;
+	const overrides = {
+		...paletteConfig.contrastLevel != null ? { contrastLevel: paletteConfig.contrastLevel } : null,
+		...seed.pastel ? { pastel: true } : null
+	};
+	const theme = glaze(hue, saturation, Object.keys(overrides).length ? overrides : void 0);
+	theme.colors({
+		...TINT_RECIPE,
+		...config.colors
+	});
+	const raw = theme.tasty({ format: "oklch" });
+	const tokens = {};
+	const colors = {};
+	for (const [key, value] of Object.entries(raw)) {
+		if (!key.startsWith("#")) {
+			tokens[key] = value;
+			continue;
+		}
+		const bare = key.slice(1);
+		const token = `#${name}-${bare}`;
+		tokens[token] = value;
+		colors[bare] = token;
+	}
+	const result = {
+		name,
+		tokens,
+		colors
+	};
+	cache.set(name, result);
+	return result;
+}
+/**
+* Register an adaptive theme's tokens once per document, and get it back.
+*
+* The tokens land on `body` under a slot keyed by the theme's name, which is a
+* hash of the config — so every component asking for the same colour shares one
+* injection no matter how many of them there are. Tasty's global-style slots are
+* also permanent, which is what makes that safe: one component unmounting cannot
+* strip tokens another is still referencing.
+*
+* `body` rather than `:root`, which emits nothing at all — the same selector
+* `GlobalStyles` uses for the palette's own tokens. Custom properties inherit, so
+* anything rendered inside the document sees them; the one thing this cannot
+* reach is content portalled outside `<body>`, which nothing does.
+*
+* Because the slot id hashes the CONFIG rather than the resolved values,
+* re-seeding the palette replaces the same slot instead of leaking a new one.
+*
+* ```tsx
+* const theme = useColorTheme({ hue: '#0ea5e9' });
+* // theme.colors.surface → '#tint-1a2b3c-surface'
+* ```
+*/
+function useColorTheme(config) {
+	usePaletteVersion();
+	const theme = getColorTheme(config);
+	useGlobalStyles("body", theme.tokens, { id: `cube-color-theme-${theme.name}` });
+	return theme;
+}
+
+//#endregion
+export { colorThemeSeed, getColorTheme, hashString, useColorTheme };
+//# sourceMappingURL=color-theme.js.map

package/dist/tokens/color-theme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-theme.js","names":[],"sources":["../../src/tokens/color-theme.ts"],"sourcesContent":["import { glaze } from '@tenphi/glaze';\nimport { useGlobalStyles } from '@tenphi/tasty';\n\n// Imported for its SIDE EFFECT as much as for `TINT_RECIPE`.\n//\n// `palette.ts` runs `glaze.configure({ states: { dark: '@dark', highContrast:\n// '@hc' }, modes: …, darkTone: … })` at module scope, and that global config is\n// what makes a theme emit `'@dark'` / `'@hc'` keys at all. Without this import\n// a runtime theme falls back to Glaze's defaults — `@media(prefers-color-scheme:\n// dark)` keys and NO high-contrast tier — which still renders, so the failure is\n// silent. `color-theme.test.ts` asserts the `'@hc'` key exists to catch it.\nimport { TINT_RECIPE } from './palette';\nimport {\n  DEFAULT_SATURATION,\n  getPaletteConfig,\n  getPaletteVersion,\n  usePaletteVersion,\n} from './palette-config';\n\nimport type { ColorMap, GlazeConfigOverride } from '@tenphi/glaze';\nimport type { Styles } from '@tenphi/tasty';\n\nexport interface ColorThemeConfig {\n  /**\n   * A hue in 0–360, or any colour Glaze parses — hex, `rgb()`, `hsl()`,\n   * `okhsl()`, `okhst()`, `oklch()`.\n   *\n   * From a colour only the HUE and SATURATION are taken; the lightness is\n   * discarded and re-derived per scheme. That is what makes the result adaptive\n   * rather than a value that happens to work in one theme.\n   */\n  hue: number | string;\n  /** 0–100. @default the palette's own saturation seed */\n  saturation?: number;\n  pastel?: boolean;\n  /**\n   * Extra colour definitions, merged over {@link TINT_RECIPE}. Anything Glaze's\n   * `theme.colors()` accepts, including `contrast` floors against a sibling.\n   */\n  colors?: ColorMap;\n}\n\nexport interface ColorTheme {\n  /**\n   * A hash of the config, and the token prefix — `'tint-1a2b3c'`.\n   *\n   * Content-addressed rather than positional so two components asking for the\n   * same colour name the same theme, and therefore share one injection. Also\n   * makes it safe to stamp on the DOM as an identifier.\n   */\n  name: string;\n  /**\n   * Tasty token declarations, one state map per colour:\n   * `{ '#tint-1a2b3c-surface': { '': …, '@dark': …, '@hc': …, '@dark & @hc': … } }`\n   */\n  tokens: Styles;\n  /** Token references by their unprefixed name — `{ surface: '#tint-1a2b3c-surface' }`. */\n  colors: Record<string, string>;\n}\n\n/**\n * FNV-1a, base36. Short, stable and dependency-free.\n *\n * These hashes name CSS custom properties and land in DOM attributes, so they\n * have to be deterministic across processes (SSR and the client must agree) and\n * safe as identifiers — but not cryptographic.\n */\nexport function hashString(input: string): string {\n  let hash = 0x811c9dc5;\n\n  for (let i = 0; i < input.length; i++) {\n    hash ^= input.charCodeAt(i);\n    // >>> 0 keeps it an unsigned 32-bit int; `Math.imul` is the 32-bit multiply.\n    hash = Math.imul(hash, 0x01000193) >>> 0;\n  }\n\n  return hash.toString(36);\n}\n\n/**\n * Hashes the RESOLVED seed, not the config as written.\n *\n * `{ hue: '#0ea5e9' }` and `{ hue: 237.32, saturation: 98.19 }` are the same\n * colour said two ways; hashing the input would give them two names, two\n * injections and two sets of generated rules. Rounded, because a seed that\n * differs in the twelfth decimal is the same colour to every eye and every\n * renderer — and an unrounded float would defeat the deduplication it is here to\n * provide.\n */\nfunction hashSeed(seed: ResolvedSeed): string {\n  return `tint-${hashString(\n    JSON.stringify([\n      seed.hue.toFixed(4),\n      seed.saturation.toFixed(4),\n      seed.pastel,\n      seed.colors ? stableStringify(seed.colors) : null,\n    ]),\n  )}`;\n}\n\ninterface ResolvedSeed {\n  hue: number;\n  saturation: number;\n  pastel: boolean;\n  colors?: ColorMap;\n}\n\n/** Key order must not change the hash, or two identical configs get two slots. */\nfunction stableStringify(value: unknown): string {\n  if (value === null || typeof value !== 'object') return JSON.stringify(value);\n\n  if (Array.isArray(value)) {\n    return `[${value.map(stableStringify).join(',')}]`;\n  }\n\n  const entries = Object.entries(value as Record<string, unknown>).sort(\n    ([a], [b]) => (a < b ? -1 : a > b ? 1 : 0),\n  );\n\n  return `{${entries\n    .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)\n    .join(',')}}`;\n}\n\n/**\n * The hue and saturation of a colour, for use as a theme seed.\n *\n * ```ts\n * colorThemeSeed('#0ea5e9'); // → { hue: 237.32, saturation: 98.19 }\n * ```\n */\nexport function colorThemeSeed(value: string): {\n  hue: number;\n  saturation: number;\n} {\n  const light = glaze.color(value).resolve().light;\n\n  // Glaze reports saturation as a 0–1 factor; the palette's seeds are 0–100.\n  return { hue: light.h, saturation: light.s * 100 };\n}\n\n/**\n * Cached by `${paletteVersion}:${name}`.\n *\n * The palette version is in the KEY rather than triggering a clear, so a stale\n * entry is simply unreachable. `lastVersion` still clears the map on a change,\n * or repeated `setPaletteConfig` calls would grow it without bound.\n */\nconst cache = new Map<string, ColorTheme>();\nlet lastVersion = -1;\n\n/**\n * Build (or reuse) an adaptive theme from a hue.\n *\n * Pure and memoized: the same config returns the same object identity until the\n * palette is re-seeded. Registering the tokens is {@link useColorTheme}'s job —\n * this only computes them, so it is safe to call while rendering or from a test.\n */\nexport function getColorTheme(config: ColorThemeConfig): ColorTheme {\n  const version = getPaletteVersion();\n\n  if (version !== lastVersion) {\n    cache.clear();\n    lastVersion = version;\n  }\n\n  const paletteConfig = getPaletteConfig();\n  const parsed =\n    typeof config.hue === 'string' ? colorThemeSeed(config.hue) : null;\n  const seed: ResolvedSeed = {\n    hue: parsed ? parsed.hue : (config.hue as number),\n    saturation:\n      config.saturation ??\n      parsed?.saturation ??\n      paletteConfig.saturation ??\n      DEFAULT_SATURATION,\n    pastel: config.pastel ?? paletteConfig.pastel ?? false,\n    colors: config.colors,\n  };\n\n  const name = hashSeed(seed);\n  const cached = cache.get(name);\n\n  if (cached) return cached;\n\n  const { hue, saturation } = seed;\n\n  // `pastel` and `contrastLevel` are instance-level in Glaze, not settable\n  // through `glaze.configure`, so a runtime theme has to carry them itself or it\n  // would ignore a pastel palette. Omitted entirely when off, so the default\n  // output is provably the same as passing nothing.\n  const overrides: GlazeConfigOverride = {\n    ...(paletteConfig.contrastLevel != null\n      ? { contrastLevel: paletteConfig.contrastLevel }\n      : null),\n    ...(seed.pastel ? { pastel: true } : null),\n  };\n\n  const theme = glaze(\n    hue,\n    saturation,\n    Object.keys(overrides).length ? overrides : undefined,\n  );\n\n  theme.colors({ ...TINT_RECIPE, ...config.colors });\n\n  // `prefix` is a palette-only option, so the keys are renamed here. `oklch`\n  // because that is what the palette emits; tasty converts to the configured\n  // colour space on the way out either way.\n  const raw = theme.tasty({ format: 'oklch' }) as Record<string, unknown>;\n  const tokens: Styles = {};\n  const colors: Record<string, string> = {};\n\n  for (const [key, value] of Object.entries(raw)) {\n    // Only the `#colour` entries are renamed; `splitHue` is off, so there are no\n    // `$…-hue` companions to worry about, but a future one must not be mangled.\n    if (!key.startsWith('#')) {\n      (tokens as Record<string, unknown>)[key] = value;\n      continue;\n    }\n\n    const bare = key.slice(1);\n    const token = `#${name}-${bare}`;\n\n    (tokens as Record<string, unknown>)[token] = value;\n    colors[bare] = token;\n  }\n\n  const result: ColorTheme = { name, tokens, colors };\n\n  cache.set(name, result);\n\n  return result;\n}\n\n/**\n * Register an adaptive theme's tokens once per document, and get it back.\n *\n * The tokens land on `body` under a slot keyed by the theme's name, which is a\n * hash of the config — so every component asking for the same colour shares one\n * injection no matter how many of them there are. Tasty's global-style slots are\n * also permanent, which is what makes that safe: one component unmounting cannot\n * strip tokens another is still referencing.\n *\n * `body` rather than `:root`, which emits nothing at all — the same selector\n * `GlobalStyles` uses for the palette's own tokens. Custom properties inherit, so\n * anything rendered inside the document sees them; the one thing this cannot\n * reach is content portalled outside `<body>`, which nothing does.\n *\n * Because the slot id hashes the CONFIG rather than the resolved values,\n * re-seeding the palette replaces the same slot instead of leaking a new one.\n *\n * ```tsx\n * const theme = useColorTheme({ hue: '#0ea5e9' });\n * // theme.colors.surface → '#tint-1a2b3c-surface'\n * ```\n */\nexport function useColorTheme(config: ColorThemeConfig): ColorTheme {\n  // Subscribes this component to a re-seed. `getColorTheme` reads the version\n  // itself for its cache, so the value is unused here — the subscription is the\n  // point, and it is what makes the tokens below re-inject.\n  usePaletteVersion();\n\n  const theme = getColorTheme(config);\n\n  useGlobalStyles('body', theme.tokens, {\n    id: `cube-color-theme-${theme.name}`,\n  });\n\n  return theme;\n}\n"],"mappings":"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"}

package/dist/tokens/colors.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-7464463 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-a5d43c3 | Cube Dev Team */
 import { getPaletteVersion } from "./palette-config.js";
 import { BASE_TOKENS } from "./base.js";
 import { lazyStyles } from "./lazy-styles.js";

package/dist/tokens/index.d.ts

@@ -3,6 +3,7 @@ import { DEFAULT_PALETTE_CONFIG, PaletteCodeSeed, PaletteConfig, PaletteThemeNam
 import { SIZES, SIZE_NAME_TO_KEY, SIZE_TOKENS, SizeKey, SizeName } from "./sizes.js";
 import { PALETTE_TOKENS, RenderPaletteOptions, getCodeTheme, getPalette, getPaletteTokens, renderPaletteTokens } from "./palette.js";
 import { COLOR_TOKENS, getColorTokens, renderColorTokens } from "./colors.js";
+import { ColorTheme, ColorThemeConfig, colorThemeSeed, getColorTheme, useColorTheme } from "./color-theme.js";
 import { SPACE_TOKENS } from "./spacing.js";
 import { SHADOW_TOKENS } from "./shadows.js";
 import { LAYOUT_TOKENS } from "./layout.js";

package/dist/tokens/index.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-7464463 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-a5d43c3 | Cube Dev Team */
 import { DEFAULT_PALETTE_CONFIG, getPaletteConfig, getPaletteConfigInput, getPaletteVersion, invalidatePaletteTokens, resetPaletteConfig, resolvePaletteConfig, setPaletteConfig, subscribePaletteConfig, usePaletteConfig, usePaletteVersion } from "./palette-config.js";
 import { BASE_TOKENS } from "./base.js";
 import { lazyStyles } from "./lazy-styles.js";
@@ -9,6 +9,7 @@ import { LAYOUT_TOKENS } from "./layout.js";
 import { SIZES, SIZE_NAME_TO_KEY, SIZE_TOKENS } from "./sizes.js";
 import { SPACE_TOKENS } from "./spacing.js";
 import { TYPOGRAPHY_PRESETS } from "./typography.js";
+import { colorThemeSeed, getColorTheme, useColorTheme } from "./color-theme.js";
 import { generateTypographyTokens } from "@tenphi/tasty";
 
 //#region src/tokens/index.ts

package/dist/tokens/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/tokens/index.ts"],"sourcesContent":["/**\n * Design tokens for the Cube UI Kit.\n *\n * This module exports all design tokens used throughout the design system.\n * All token keys use $ prefix for CSS custom properties.\n *\n * Categories:\n * - Colors: Base color palette with -color and -color-rgb variants\n * - Typography: Font presets for headings, text, paragraphs, etc.\n * - Sizes: Component size values (XS, SM, MD, LG, XL)\n * - Spacing: Space tokens using gap multipliers\n * - Shadows: Shadow definitions for elevation\n * - Layout: Common layout dimensions\n * - Base: Core design system values\n */\n\nimport { generateTypographyTokens } from '@tenphi/tasty';\n\nimport { BASE_TOKENS } from './base';\nimport { getColorTokens } from './colors';\nimport { LAYOUT_TOKENS } from './layout';\nimport { lazyStyles } from './lazy-styles';\nimport { getPaletteVersion } from './palette-config';\nimport { SHADOW_TOKENS } from './shadows';\nimport { SIZE_TOKENS } from './sizes';\nimport { SPACE_TOKENS } from './spacing';\nimport { TYPOGRAPHY_PRESETS } from './typography';\n\nimport type { Styles } from '@tenphi/tasty';\nimport type { SizeKey, SizeName } from './sizes';\n\n/**\n * All design tokens combined into a single Styles object.\n * Keys use $ prefix for CSS custom properties.\n *\n * Color tokens resolve against the current palette config (see\n * {@link getColorTokens}), and this map is memoized against that config's\n * version so `setPaletteConfig()` invalidates it. Prefer this over the lazy\n * {@link TOKENS} proxy when applying styles from React (`GlobalStyles`).\n *\n * Includes:\n * - Base tokens ($gap, $radius, etc.)\n * - Space tokens ($space-xs, $space-sm, etc.)\n * - Size tokens ($size-xs, $size-sm, etc.)\n * - Shadow tokens ($shadow, $item-shadow, etc.)\n * - Layout tokens ($max-content-width, $topbar-height, etc.)\n * - Typography tokens ($h1-font-size, $t3-line-height, etc.)\n * - Color tokens ($purple-color, $purple-color-rgb, etc.)\n */\nlet tokensCache: Styles | null = null;\nlet cachedVersion = -1;\n\nexport function getTokens(): Styles {\n  const version = getPaletteVersion();\n\n  if (!tokensCache || cachedVersion !== version) {\n    tokensCache = {\n      ...BASE_TOKENS,\n      ...SPACE_TOKENS,\n      ...SIZE_TOKENS,\n      ...SHADOW_TOKENS,\n      ...LAYOUT_TOKENS,\n      ...generateTypographyTokens(TYPOGRAPHY_PRESETS),\n      ...getColorTokens(),\n    };\n    cachedVersion = version;\n  }\n  return tokensCache;\n}\n\n/** Lazy proxy of {@link getTokens}. Prefer `getTokens()` in new code. */\nexport const TOKENS: Styles = lazyStyles(getTokens);\n\n// Re-export category modules for direct access\nexport { COLOR_TOKENS, getColorTokens, renderColorTokens } from './colors';\nexport {\n  getCodeTheme,\n  getPalette,\n  getPaletteTokens,\n  PALETTE_TOKENS,\n  renderPaletteTokens,\n} from './palette';\nexport type { RenderPaletteOptions } from './palette';\nexport {\n  DEFAULT_PALETTE_CONFIG,\n  getPaletteConfig,\n  getPaletteConfigInput,\n  invalidatePaletteTokens,\n  resetPaletteConfig,\n  resolvePaletteConfig,\n  setPaletteConfig,\n  subscribePaletteConfig,\n  usePaletteConfig,\n  usePaletteVersion,\n} from './palette-config';\nexport type {\n  PaletteCodeSeed,\n  PaletteConfig,\n  PaletteThemeName,\n  PaletteThemeSeed,\n  ResolvedPaletteConfig,\n} from './palette-config';\nexport { SIZES, SIZE_NAME_TO_KEY, SIZE_TOKENS } from './sizes';\nexport type { SizeKey, SizeName } from './sizes';\nexport { SPACE_TOKENS } from './spacing';\nexport { SHADOW_TOKENS } from './shadows';\nexport { LAYOUT_TOKENS } from './layout';\nexport { BASE_TOKENS } from './base';\nexport { TYPOGRAPHY_PRESETS } from './typography';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,IAAI,cAA6B;AACjC,IAAI,gBAAgB;AAEpB,SAAgB,YAAoB;CAClC,MAAM,UAAU,mBAAmB;AAEnC,KAAI,CAAC,eAAe,kBAAkB,SAAS;AAC7C,gBAAc;GACZ,GAAG;GACH,GAAG;GACH,GAAG;GACH,GAAG;GACH,GAAG;GACH,GAAG,yBAAyB,mBAAmB;GAC/C,GAAG,gBAAgB;GACpB;AACD,kBAAgB;;AAElB,QAAO;;;AAIT,MAAa,SAAiB,WAAW,UAAU"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/tokens/index.ts"],"sourcesContent":["/**\n * Design tokens for the Cube UI Kit.\n *\n * This module exports all design tokens used throughout the design system.\n * All token keys use $ prefix for CSS custom properties.\n *\n * Categories:\n * - Colors: Base color palette with -color and -color-rgb variants\n * - Typography: Font presets for headings, text, paragraphs, etc.\n * - Sizes: Component size values (XS, SM, MD, LG, XL)\n * - Spacing: Space tokens using gap multipliers\n * - Shadows: Shadow definitions for elevation\n * - Layout: Common layout dimensions\n * - Base: Core design system values\n */\n\nimport { generateTypographyTokens } from '@tenphi/tasty';\n\nimport { BASE_TOKENS } from './base';\nimport { getColorTokens } from './colors';\nimport { LAYOUT_TOKENS } from './layout';\nimport { lazyStyles } from './lazy-styles';\nimport { getPaletteVersion } from './palette-config';\nimport { SHADOW_TOKENS } from './shadows';\nimport { SIZE_TOKENS } from './sizes';\nimport { SPACE_TOKENS } from './spacing';\nimport { TYPOGRAPHY_PRESETS } from './typography';\n\nimport type { Styles } from '@tenphi/tasty';\nimport type { SizeKey, SizeName } from './sizes';\n\n/**\n * All design tokens combined into a single Styles object.\n * Keys use $ prefix for CSS custom properties.\n *\n * Color tokens resolve against the current palette config (see\n * {@link getColorTokens}), and this map is memoized against that config's\n * version so `setPaletteConfig()` invalidates it. Prefer this over the lazy\n * {@link TOKENS} proxy when applying styles from React (`GlobalStyles`).\n *\n * Includes:\n * - Base tokens ($gap, $radius, etc.)\n * - Space tokens ($space-xs, $space-sm, etc.)\n * - Size tokens ($size-xs, $size-sm, etc.)\n * - Shadow tokens ($shadow, $item-shadow, etc.)\n * - Layout tokens ($max-content-width, $topbar-height, etc.)\n * - Typography tokens ($h1-font-size, $t3-line-height, etc.)\n * - Color tokens ($purple-color, $purple-color-rgb, etc.)\n */\nlet tokensCache: Styles | null = null;\nlet cachedVersion = -1;\n\nexport function getTokens(): Styles {\n  const version = getPaletteVersion();\n\n  if (!tokensCache || cachedVersion !== version) {\n    tokensCache = {\n      ...BASE_TOKENS,\n      ...SPACE_TOKENS,\n      ...SIZE_TOKENS,\n      ...SHADOW_TOKENS,\n      ...LAYOUT_TOKENS,\n      ...generateTypographyTokens(TYPOGRAPHY_PRESETS),\n      ...getColorTokens(),\n    };\n    cachedVersion = version;\n  }\n  return tokensCache;\n}\n\n/** Lazy proxy of {@link getTokens}. Prefer `getTokens()` in new code. */\nexport const TOKENS: Styles = lazyStyles(getTokens);\n\n// Re-export category modules for direct access\nexport { COLOR_TOKENS, getColorTokens, renderColorTokens } from './colors';\n// Adaptive one-off themes built at runtime from an arbitrary hue, named by a\n// hash of their config so identical requests share one injection.\nexport { colorThemeSeed, getColorTheme, useColorTheme } from './color-theme';\nexport type { ColorTheme, ColorThemeConfig } from './color-theme';\nexport {\n  getCodeTheme,\n  getPalette,\n  getPaletteTokens,\n  PALETTE_TOKENS,\n  renderPaletteTokens,\n} from './palette';\nexport type { RenderPaletteOptions } from './palette';\nexport {\n  DEFAULT_PALETTE_CONFIG,\n  getPaletteConfig,\n  getPaletteConfigInput,\n  invalidatePaletteTokens,\n  resetPaletteConfig,\n  resolvePaletteConfig,\n  setPaletteConfig,\n  subscribePaletteConfig,\n  usePaletteConfig,\n  usePaletteVersion,\n} from './palette-config';\nexport type {\n  PaletteCodeSeed,\n  PaletteConfig,\n  PaletteThemeName,\n  PaletteThemeSeed,\n  ResolvedPaletteConfig,\n} from './palette-config';\nexport { SIZES, SIZE_NAME_TO_KEY, SIZE_TOKENS } from './sizes';\nexport type { SizeKey, SizeName } from './sizes';\nexport { SPACE_TOKENS } from './spacing';\nexport { SHADOW_TOKENS } from './shadows';\nexport { LAYOUT_TOKENS } from './layout';\nexport { BASE_TOKENS } from './base';\nexport { TYPOGRAPHY_PRESETS } from './typography';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,IAAI,cAA6B;AACjC,IAAI,gBAAgB;AAEpB,SAAgB,YAAoB;CAClC,MAAM,UAAU,mBAAmB;AAEnC,KAAI,CAAC,eAAe,kBAAkB,SAAS;AAC7C,gBAAc;GACZ,GAAG;GACH,GAAG;GACH,GAAG;GACH,GAAG;GACH,GAAG;GACH,GAAG,yBAAyB,mBAAmB;GAC/C,GAAG,gBAAgB;GACpB;AACD,kBAAgB;;AAElB,QAAO;;;AAIT,MAAa,SAAiB,WAAW,UAAU"}

package/dist/tokens/layout.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-7464463 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-a5d43c3 | Cube Dev Team */
 //#region src/tokens/layout.ts
 /**
 * Layout-related tokens for common UI dimensions.

package/dist/tokens/lazy-styles.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-7464463 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-a5d43c3 | Cube Dev Team */
 //#region src/tokens/lazy-styles.ts
 /**
 * Proxy that defers to `factory()` on every property / enumeration access.

package/dist/tokens/palette-config.d.ts

@@ -19,7 +19,7 @@ interface PaletteThemeSeed {
  * reason.
  */
 interface PaletteCodeSeed {
-  /** Saturation (0–100). Defaults to {@link DEFAULT_CODE_SATURATION}, not to `saturation`. */
+  /** Saturation (0–100). Defaults to {@link DEFAULT_SATURATION}, not to `saturation`. */
   saturation?: number;
 }
 /** Names of the themes whose seeds can be overridden individually. */

package/dist/tokens/palette-config.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-7464463 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-a5d43c3 | Cube Dev Team */
 import { useSyncExternalStore } from "react";
 
 //#region src/tokens/palette-config.ts
@@ -20,19 +20,7 @@ const DEFAULT_DANGER_HUE = 23.1;
 const DEFAULT_WARNING_HUE = 84.3;
 const DEFAULT_NOTE_HUE = 302.3;
 /** Seed saturation. Per-color `saturation` in the recipe is a 0–1 factor of it. */
-const DEFAULT_SATURATION = 100;
-/**
-* Seed saturation for the `code-*` syntax family, deliberately **not** the same
-* constant as {@link DEFAULT_SATURATION}.
-*
-* The two were one value until the app seed moved to 100 for the pastel palette.
-* Sharing it would have dragged the syntax colors along for the ride — the exact
-* coupling that `PaletteCodeSeed` and the `pastel` opt-out both exist to prevent,
-* and the reason the code family answers to its own saturation and nothing else.
-* Splitting the constant is what lets the app seed move while the code palette
-* stays on the value it was calibrated against.
-*/
-const DEFAULT_CODE_SATURATION = 80;
+const DEFAULT_SATURATION = 80;
 const DEFAULT_THEME_HUES = {
 	success: DEFAULT_SUCCESS_HUE,
 	danger: DEFAULT_DANGER_HUE,
@@ -47,7 +35,7 @@ function resolveConfig(input) {
 		hue,
 		baseHue: input.baseHue ?? hue,
 		saturation,
-		pastel: input.pastel ?? true,
+		pastel: input.pastel ?? false,
 		contrastLevel: input.contrastLevel ?? "auto",
 		themes: {
 			success: {
@@ -66,7 +54,7 @@ function resolveConfig(input) {
 				hue: themes.note?.hue ?? DEFAULT_THEME_HUES.note,
 				saturation: themes.note?.saturation ?? saturation
 			},
-			code: { saturation: themes.code?.saturation ?? DEFAULT_CODE_SATURATION }
+			code: { saturation: themes.code?.saturation ?? DEFAULT_SATURATION }
 		}
 	};
 }
@@ -317,5 +305,5 @@ function usePaletteConfig() {
 }
 
 //#endregion
-export { DEFAULT_PALETTE_CONFIG, getPaletteConfig, getPaletteConfigInput, getPaletteVersion, invalidatePaletteTokens, resetPaletteConfig, resolvePaletteConfig, setPaletteConfig, subscribePaletteConfig, usePaletteConfig, usePaletteVersion };
+export { DEFAULT_PALETTE_CONFIG, DEFAULT_SATURATION, getPaletteConfig, getPaletteConfigInput, getPaletteVersion, invalidatePaletteTokens, resetPaletteConfig, resolvePaletteConfig, setPaletteConfig, subscribePaletteConfig, usePaletteConfig, usePaletteVersion };
 //# sourceMappingURL=palette-config.js.map

package/dist/tokens/palette-config.js.map

@@ -1 +1 @@
-{"version":3,"file":"palette-config.js","names":[],"sources":["../../src/tokens/palette-config.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react';\n\n/**\n * Runtime configuration for the Glaze-generated color palette.\n *\n * The palette recipe itself lives in `./palette.ts`; this module owns only the\n * *seeds* it is built from, plus a version counter the token caches watch. It\n * deliberately imports nothing else — not the token modules, not `glaze` — so\n * there is no import cycle and no ordering hazard.\n *\n * Reading is free; writing rebuilds the palette on the next token read. See\n * `Getting Started/Theming` in Storybook for the full contract.\n */\n\n// ============================================================================\n// Default seeds\n// ============================================================================\n\n/** Brand hue. Drives the `default`, `primary`, `purple` and `special` themes. */\nexport const DEFAULT_HUE = 280.3;\nexport const DEFAULT_SUCCESS_HUE = 156.9;\nexport const DEFAULT_DANGER_HUE = 23.1;\nexport const DEFAULT_WARNING_HUE = 84.3;\nexport const DEFAULT_NOTE_HUE = 302.3;\n\n/** Seed saturation. Per-color `saturation` in the recipe is a 0–1 factor of it. */\nexport const DEFAULT_SATURATION = 100;\n\n/**\n * Seed saturation for the `code-*` syntax family, deliberately **not** the same\n * constant as {@link DEFAULT_SATURATION}.\n *\n * The two were one value until the app seed moved to 100 for the pastel palette.\n * Sharing it would have dragged the syntax colors along for the ride — the exact\n * coupling that `PaletteCodeSeed` and the `pastel` opt-out both exist to prevent,\n * and the reason the code family answers to its own saturation and nothing else.\n * Splitting the constant is what lets the app seed move while the code palette\n * stays on the value it was calibrated against.\n */\nexport const DEFAULT_CODE_SATURATION = 80;\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** Hue / saturation seed override for one colored theme. */\nexport interface PaletteThemeSeed {\n  /** Hue in degrees (0–360). */\n  hue?: number;\n  /** Saturation (0–100). Defaults to the palette-level `saturation`. */\n  saturation?: number;\n}\n\n/**\n * The `code-*` syntax family takes a saturation and nothing else — and answers to\n * nothing else either. This is the one knob that moves it.\n *\n * Its hues are absolute literals by design, so syntax colors never rotate with the\n * brand — strings would collide with numbers the moment the brand went green. Unlike\n * every other theme, its saturation does **not** inherit the palette-level one: the\n * code palette is calibrated once and stays there, so re-seeding the app cannot\n * quietly wash out a code block. {@link PaletteConfig.pastel} skips it for the same\n * reason.\n */\nexport interface PaletteCodeSeed {\n  /** Saturation (0–100). Defaults to {@link DEFAULT_CODE_SATURATION}, not to `saturation`. */\n  saturation?: number;\n}\n\n/** Names of the themes whose seeds can be overridden individually. */\nexport type PaletteThemeName =\n  | 'success'\n  | 'danger'\n  | 'warning'\n  | 'note'\n  | 'code';\n\n/**\n * Palette tuning. Every field is optional; omitted fields keep their default,\n * and per-theme fields left unset inherit the palette-level value.\n */\nexport interface PaletteConfig {\n  /**\n   * Accent hue in degrees (0–360) — the brand.\n   *\n   * Drives the `accent-*` family on every theme, `primary` / `purple` / `special`,\n   * and the brand-tinted odds and ends (`focus`, the loading faces, the disabled\n   * chip). Also the default for {@link PaletteConfig.baseHue}.\n   */\n  hue?: number;\n  /**\n   * Hue of the **base** zone in degrees (0–360): the neutral chrome — `surface`\n   * and its ladder, the `surface-text*` ramp, `border`, `placeholder`. Defaults to\n   * `hue`, so the chrome carries a faint tint of the brand unless you say otherwise.\n   *\n   * Splitting it lets the chrome sit on a different hue from the accent — a warm\n   * grey UI with a cool blue brand, say. Only the `default` theme is affected: a\n   * colored theme's tinted `surface` deliberately follows *its own* hue, because a\n   * danger banner should read as red.\n   */\n  baseHue?: number;\n  /**\n   * Seed saturation (0–100), and the fallback for every theme that does not set\n   * its own.\n   *\n   * One scale for the whole theme, by design. Every color's own `saturation` is a\n   * 0–1 factor of this seed — `surface` at 0.12, `border` at 0.175, the text ramp\n   * at 0.2, the accent family at ~1.0 — so moving it rescales the palette while\n   * keeping those proportions. Unlike hue, which is configured separately for the\n   * brand and for each status theme, saturation is deliberately not split: the\n   * ratio between a subtle surface tint and a saturated accent is part of the\n   * design.\n   */\n  saturation?: number;\n  /**\n   * Global. Widens the usable chroma range by relaxing the sRGB-safe limit,\n   * producing a softer, more even palette across hues. Glaze treats `pastel` as\n   * instance-level, so it is threaded into every theme.\n   *\n   * Every theme except `code`. The syntax family is calibrated on its own\n   * saturation and is deliberately left out — softening it collapses the chroma\n   * spread the syntax hues rely on to stay apart. To soften a code block, lower\n   * {@link PaletteCodeSeed.saturation} instead.\n   */\n  pastel?: boolean;\n  /**\n   * Global. `'auto'` (the default) keeps the two-tier model: normal colors plus\n   * a separate high-contrast tier driven by `<html data-contrast=\"high\">` /\n   * `prefers-contrast: more`.\n   *\n   * A number (0–100) replaces that switch with a slider — and, because a manual\n   * level already carries the contrast preference, **drops the high-contrast\n   * tier entirely**. `0` reproduces the normal output and `100` the\n   * high-contrast output, bit for bit.\n   */\n  contrastLevel?: number | 'auto';\n  /** Per-theme seed overrides. */\n  themes?: {\n    success?: PaletteThemeSeed;\n    danger?: PaletteThemeSeed;\n    warning?: PaletteThemeSeed;\n    note?: PaletteThemeSeed;\n    code?: PaletteCodeSeed;\n  };\n}\n\n/** {@link PaletteConfig} with every field resolved to a concrete value. */\nexport interface ResolvedPaletteConfig {\n  hue: number;\n  baseHue: number;\n  saturation: number;\n  pastel: boolean;\n  contrastLevel: number | 'auto';\n  themes: {\n    success: { hue: number; saturation: number };\n    danger: { hue: number; saturation: number };\n    warning: { hue: number; saturation: number };\n    note: { hue: number; saturation: number };\n    code: { saturation: number };\n  };\n}\n\n// ============================================================================\n// Resolution\n// ============================================================================\n\nconst DEFAULT_THEME_HUES = {\n  success: DEFAULT_SUCCESS_HUE,\n  danger: DEFAULT_DANGER_HUE,\n  warning: DEFAULT_WARNING_HUE,\n  note: DEFAULT_NOTE_HUE,\n} as const;\n\nfunction resolveConfig(input: PaletteConfig): ResolvedPaletteConfig {\n  const saturation = input.saturation ?? DEFAULT_SATURATION;\n  const themes = input.themes ?? {};\n\n  const hue = input.hue ?? DEFAULT_HUE;\n\n  return {\n    hue,\n    baseHue: input.baseHue ?? hue,\n    saturation,\n    pastel: input.pastel ?? true,\n    contrastLevel: input.contrastLevel ?? 'auto',\n    themes: {\n      success: {\n        hue: themes.success?.hue ?? DEFAULT_THEME_HUES.success,\n        saturation: themes.success?.saturation ?? saturation,\n      },\n      danger: {\n        hue: themes.danger?.hue ?? DEFAULT_THEME_HUES.danger,\n        saturation: themes.danger?.saturation ?? saturation,\n      },\n      warning: {\n        hue: themes.warning?.hue ?? DEFAULT_THEME_HUES.warning,\n        saturation: themes.warning?.saturation ?? saturation,\n      },\n      note: {\n        hue: themes.note?.hue ?? DEFAULT_THEME_HUES.note,\n        saturation: themes.note?.saturation ?? saturation,\n      },\n      // Deliberately NOT `?? saturation`: the code palette is calibrated once and\n      // does not follow the palette-level seed. See `PaletteCodeSeed`.\n      code: { saturation: themes.code?.saturation ?? DEFAULT_CODE_SATURATION },\n    },\n  };\n}\n\n/**\n * The palette as it ships, with no tuning applied. Frozen — it is the baseline\n * every resolution falls back to, so a stray write to it would move the defaults\n * for the whole process.\n */\nexport const DEFAULT_PALETTE_CONFIG: ResolvedPaletteConfig = freezeConfig(\n  resolveConfig({}),\n);\n\n// ============================================================================\n// Store\n// ============================================================================\n\n/**\n * The last config *as written*, sparse — not the resolved one. Keeping the sparse\n * form is what makes inheritance live: a `saturation` with no `themes.danger.\n * saturation` beside it means danger genuinely follows the palette, rather than\n * having been frozen at whatever the palette read when it was set.\n */\nlet input: PaletteConfig = {};\nlet resolved: ResolvedPaletteConfig = DEFAULT_PALETTE_CONFIG;\nlet version = 0;\n\nconst listeners = new Set<() => void>();\n\nfunction mergeSeed<T extends PaletteThemeSeed | PaletteCodeSeed>(\n  base: T | undefined,\n  patch: T | undefined,\n): T | undefined {\n  if (!base) return patch;\n  // A patch that omits the theme entirely says nothing about it, so the base\n  // survives. Clearing one of its fields is `{ theme: { hue: undefined } }`.\n  if (!patch) return base;\n\n  return { ...base, ...patch };\n}\n\n/**\n * Layer a patch over a base config. Used by {@link resolvePaletteConfig} for\n * previews — *not* by {@link setPaletteConfig}, which replaces.\n */\nfunction mergeInput(base: PaletteConfig, patch: PaletteConfig): PaletteConfig {\n  const next: PaletteConfig = { ...base, ...patch };\n\n  if (base.themes || patch.themes) {\n    next.themes = {\n      success: mergeSeed(base.themes?.success, patch.themes?.success),\n      danger: mergeSeed(base.themes?.danger, patch.themes?.danger),\n      warning: mergeSeed(base.themes?.warning, patch.themes?.warning),\n      note: mergeSeed(base.themes?.note, patch.themes?.note),\n      code: mergeSeed(base.themes?.code, patch.themes?.code),\n    };\n  }\n\n  return next;\n}\n\nfunction isSameConfig(a: ResolvedPaletteConfig, b: ResolvedPaletteConfig) {\n  return (\n    a.hue === b.hue &&\n    a.baseHue === b.baseHue &&\n    a.saturation === b.saturation &&\n    a.pastel === b.pastel &&\n    a.contrastLevel === b.contrastLevel &&\n    a.themes.code.saturation === b.themes.code.saturation &&\n    (['success', 'danger', 'warning', 'note'] as const).every(\n      (name) =>\n        a.themes[name].hue === b.themes[name].hue &&\n        a.themes[name].saturation === b.themes[name].saturation,\n    )\n  );\n}\n\n/**\n * Which fields are *explicitly set*, as an order-independent signature.\n *\n * Two configs can resolve to identical values yet differ in which of those values\n * are pinned rather than inherited — pinning `primary.saturation` to the number it\n * already inherited is the obvious case. That difference is invisible to\n * {@link isSameConfig} but visible through {@link getPaletteConfigInput}, so it has\n * to count as a change or a settings UI reading it would never re-render.\n */\nfunction pinSignature(config: PaletteConfig): string {\n  const set = (value: unknown) => (value === undefined ? '0' : '1');\n\n  return [\n    set(config.hue),\n    set(config.baseHue),\n    set(config.saturation),\n    set(config.pastel),\n    set(config.contrastLevel),\n    set(config.themes?.code?.saturation),\n    ...(['success', 'danger', 'warning', 'note'] as const).flatMap((name) => [\n      set(config.themes?.[name]?.hue),\n      set(config.themes?.[name]?.saturation),\n    ]),\n  ].join('');\n}\n\n/**\n * Snapshot a config so the store owns it outright.\n *\n * Two hazards this closes. The caller's object stays theirs, so mutating it after\n * the call cannot desync `input` from `resolved`. And what we hand back from\n * {@link getPaletteConfig} / {@link getPaletteConfigInput} is frozen, so a caller\n * who writes to it gets a clear failure rather than silently corrupting the store\n * — the version would not bump, and every token cache would go on serving values\n * that no longer match the config.\n */\nfunction freezeConfig<T extends PaletteConfig | ResolvedPaletteConfig>(\n  config: T,\n): T {\n  const themes = config.themes;\n\n  if (themes) {\n    for (const seed of Object.values(themes)) {\n      if (seed) Object.freeze(seed);\n    }\n    Object.freeze(themes);\n  }\n\n  return Object.freeze(config);\n}\n\n/** {@link freezeConfig} on a copy, for a config we did not create ourselves. */\nfunction snapshotConfig(config: PaletteConfig): PaletteConfig {\n  const themes = config.themes;\n\n  return freezeConfig({\n    ...config,\n    ...(themes\n      ? {\n          themes: {\n            ...(themes.success ? { success: { ...themes.success } } : null),\n            ...(themes.danger ? { danger: { ...themes.danger } } : null),\n            ...(themes.warning ? { warning: { ...themes.warning } } : null),\n            ...(themes.note ? { note: { ...themes.note } } : null),\n            ...(themes.code ? { code: { ...themes.code } } : null),\n          },\n        }\n      : null),\n  });\n}\n\nfunction commit(nextInput: PaletteConfig) {\n  const nextResolved = resolveConfig(nextInput);\n\n  // Bail before bumping the version when nothing observable moved, so re-applying\n  // the same config — an inline `<Root palette={{ … }}>` literal on every\n  // render, a StrictMode double render — costs nothing.\n  if (\n    isSameConfig(resolved, nextResolved) &&\n    pinSignature(input) === pinSignature(nextInput)\n  ) {\n    return;\n  }\n\n  input = snapshotConfig(nextInput);\n  resolved = freezeConfig(nextResolved);\n  version++;\n\n  listeners.forEach((listener) => listener());\n}\n\n/**\n * Set the palette config.\n *\n * **Replaces**, like `useState` — the config you pass *is* the config, resolved\n * against the shipped defaults. Nothing accumulates, so a field you leave out is a\n * field you do not have: dropping a customization means dropping it from the\n * object, and re-applying the same object twice is the same as applying it once.\n *\n * ```ts\n * setPaletteConfig({ hue: 200, baseHue: 60 });\n * setPaletteConfig({ hue: 200 }); // baseHue is gone — back to inheriting `hue`\n * ```\n *\n * To adjust one field of the config already in place — a slider in a settings UI —\n * pass an updater. It receives the config as written, sparse, so spreading it\n * preserves which fields are pinned and which still inherit:\n *\n * ```ts\n * setPaletteConfig((config) => ({ ...config, hue: 200 }));\n * ```\n *\n * The palette is rebuilt lazily on the next token read, and any mounted `<Root>`\n * re-injects the token block — no component re-render is involved, because every\n * color in the kit resolves through a CSS custom property.\n */\nexport function setPaletteConfig(\n  config: PaletteConfig | ((previous: PaletteConfig) => PaletteConfig),\n): void {\n  commit(typeof config === 'function' ? config(input) : config);\n}\n\n/**\n * Drop all tuning and restore the palette the kit ships with. Identical to\n * `setPaletteConfig({})`; it exists to be readable at a call site.\n */\nexport function resetPaletteConfig(): void {\n  commit({});\n}\n\n/**\n * Force every token to re-resolve without changing the palette config.\n *\n * Only needed if you drive Glaze directly — `glaze.configure({ darkTone })` and\n * the like. Glaze invalidates its own caches, but the kit's token maps are\n * memoized against *this* module's version, so they need telling. Calling it\n * before the first paint is unnecessary; nothing has been resolved yet.\n */\nexport function invalidatePaletteTokens(): void {\n  version++;\n  listeners.forEach((listener) => listener());\n}\n\n/** The current config, with every field resolved to a concrete value. */\nexport function getPaletteConfig(): ResolvedPaletteConfig {\n  return resolved;\n}\n\n/**\n * The config **as set**, sparse — omitted fields are the ones still inheriting.\n *\n * {@link getPaletteConfig} resolves everything to concrete values, which loses the\n * distinction between \"explicitly 80\" and \"80 because it follows the brand\". A\n * settings UI needs that distinction to show an inherited value as inherited, and\n * to offer a way back:\n *\n * ```ts\n * const pinned = getPaletteConfigInput().baseHue !== undefined;\n *\n * // Re-link it to the brand by dropping the field.\n * setPaletteConfig(({ baseHue, ...config }) => config);\n * ```\n *\n * It is also the value handed to a {@link setPaletteConfig} updater.\n */\nexport function getPaletteConfigInput(): PaletteConfig {\n  return input;\n}\n\n/**\n * Resolve a patch **over** the current config, without applying it.\n *\n * This one layers, unlike {@link setPaletteConfig}: a preview wants \"the theme in\n * use, but in dark\", so the fields it does not mention have to come from the live\n * config rather than from the defaults. The store is not touched and no listener\n * fires.\n */\nexport function resolvePaletteConfig(\n  config?: PaletteConfig,\n): ResolvedPaletteConfig {\n  if (!config) return resolved;\n\n  return resolveConfig(mergeInput(input, config));\n}\n\n/**\n * Increments whenever the resolved config changes. The token caches in\n * `./palette.ts`, `./colors.ts` and `./index.ts` compare against it instead of\n * memoizing forever — the same idiom Glaze uses for its own config version.\n */\nexport function getPaletteVersion(): number {\n  return version;\n}\n\n/** Subscribe to palette config changes. Returns an unsubscribe function. */\nexport function subscribePaletteConfig(listener: () => void): () => void {\n  listeners.add(listener);\n\n  return () => {\n    listeners.delete(listener);\n  };\n}\n\n// ============================================================================\n// React bindings\n// ============================================================================\n\n/**\n * Re-render on palette config changes. Returns the version, not the config, so\n * the snapshot is a primitive and React never warns about an uncached snapshot.\n */\nexport function usePaletteVersion(): number {\n  return useSyncExternalStore(\n    subscribePaletteConfig,\n    getPaletteVersion,\n    getPaletteVersion,\n  );\n}\n\n/**\n * Read and tune the palette from React, `useState`-style — including the part\n * where the setter *replaces*. A control that changes one field wants the updater\n * form, or it will drop every other field:\n *\n * ```tsx\n * const [palette, setPalette] = usePaletteConfig();\n *\n * <HueSlider\n *   value={palette.hue}\n *   onChange={(hue) => setPalette((config) => ({ ...config, hue }))}\n * />\n * ```\n *\n * The first element is the *resolved* config, so `palette.hue` is always a number.\n * The updater's argument is the sparse one — see {@link getPaletteConfigInput}.\n *\n * The config is global process state, so every consumer of this hook — and every\n * mounted `<Root>` — sees the same palette.\n */\nexport function usePaletteConfig(): readonly [\n  ResolvedPaletteConfig,\n  typeof setPaletteConfig,\n] {\n  usePaletteVersion();\n\n  return [getPaletteConfig(), setPaletteConfig];\n}\n"],"mappings":"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"}
+{"version":3,"file":"palette-config.js","names":[],"sources":["../../src/tokens/palette-config.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react';\n\n/**\n * Runtime configuration for the Glaze-generated color palette.\n *\n * The palette recipe itself lives in `./palette.ts`; this module owns only the\n * *seeds* it is built from, plus a version counter the token caches watch. It\n * deliberately imports nothing else — not the token modules, not `glaze` — so\n * there is no import cycle and no ordering hazard.\n *\n * Reading is free; writing rebuilds the palette on the next token read. See\n * `Getting Started/Theming` in Storybook for the full contract.\n */\n\n// ============================================================================\n// Default seeds\n// ============================================================================\n\n/** Brand hue. Drives the `default`, `primary`, `purple` and `special` themes. */\nexport const DEFAULT_HUE = 280.3;\nexport const DEFAULT_SUCCESS_HUE = 156.9;\nexport const DEFAULT_DANGER_HUE = 23.1;\nexport const DEFAULT_WARNING_HUE = 84.3;\nexport const DEFAULT_NOTE_HUE = 302.3;\n\n/** Seed saturation. Per-color `saturation` in the recipe is a 0–1 factor of it. */\nexport const DEFAULT_SATURATION = 80;\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/** Hue / saturation seed override for one colored theme. */\nexport interface PaletteThemeSeed {\n  /** Hue in degrees (0–360). */\n  hue?: number;\n  /** Saturation (0–100). Defaults to the palette-level `saturation`. */\n  saturation?: number;\n}\n\n/**\n * The `code-*` syntax family takes a saturation and nothing else — and answers to\n * nothing else either. This is the one knob that moves it.\n *\n * Its hues are absolute literals by design, so syntax colors never rotate with the\n * brand — strings would collide with numbers the moment the brand went green. Unlike\n * every other theme, its saturation does **not** inherit the palette-level one: the\n * code palette is calibrated once and stays there, so re-seeding the app cannot\n * quietly wash out a code block. {@link PaletteConfig.pastel} skips it for the same\n * reason.\n */\nexport interface PaletteCodeSeed {\n  /** Saturation (0–100). Defaults to {@link DEFAULT_SATURATION}, not to `saturation`. */\n  saturation?: number;\n}\n\n/** Names of the themes whose seeds can be overridden individually. */\nexport type PaletteThemeName =\n  | 'success'\n  | 'danger'\n  | 'warning'\n  | 'note'\n  | 'code';\n\n/**\n * Palette tuning. Every field is optional; omitted fields keep their default,\n * and per-theme fields left unset inherit the palette-level value.\n */\nexport interface PaletteConfig {\n  /**\n   * Accent hue in degrees (0–360) — the brand.\n   *\n   * Drives the `accent-*` family on every theme, `primary` / `purple` / `special`,\n   * and the brand-tinted odds and ends (`focus`, the loading faces, the disabled\n   * chip). Also the default for {@link PaletteConfig.baseHue}.\n   */\n  hue?: number;\n  /**\n   * Hue of the **base** zone in degrees (0–360): the neutral chrome — `surface`\n   * and its ladder, the `surface-text*` ramp, `border`, `placeholder`. Defaults to\n   * `hue`, so the chrome carries a faint tint of the brand unless you say otherwise.\n   *\n   * Splitting it lets the chrome sit on a different hue from the accent — a warm\n   * grey UI with a cool blue brand, say. Only the `default` theme is affected: a\n   * colored theme's tinted `surface` deliberately follows *its own* hue, because a\n   * danger banner should read as red.\n   */\n  baseHue?: number;\n  /**\n   * Seed saturation (0–100), and the fallback for every theme that does not set\n   * its own.\n   *\n   * One scale for the whole theme, by design. Every color's own `saturation` is a\n   * 0–1 factor of this seed — `surface` at 0.12, `border` at 0.175, the text ramp\n   * at 0.2, the accent family at ~1.0 — so moving it rescales the palette while\n   * keeping those proportions. Unlike hue, which is configured separately for the\n   * brand and for each status theme, saturation is deliberately not split: the\n   * ratio between a subtle surface tint and a saturated accent is part of the\n   * design.\n   */\n  saturation?: number;\n  /**\n   * Global. Widens the usable chroma range by relaxing the sRGB-safe limit,\n   * producing a softer, more even palette across hues. Glaze treats `pastel` as\n   * instance-level, so it is threaded into every theme.\n   *\n   * Every theme except `code`. The syntax family is calibrated on its own\n   * saturation and is deliberately left out — softening it collapses the chroma\n   * spread the syntax hues rely on to stay apart. To soften a code block, lower\n   * {@link PaletteCodeSeed.saturation} instead.\n   */\n  pastel?: boolean;\n  /**\n   * Global. `'auto'` (the default) keeps the two-tier model: normal colors plus\n   * a separate high-contrast tier driven by `<html data-contrast=\"high\">` /\n   * `prefers-contrast: more`.\n   *\n   * A number (0–100) replaces that switch with a slider — and, because a manual\n   * level already carries the contrast preference, **drops the high-contrast\n   * tier entirely**. `0` reproduces the normal output and `100` the\n   * high-contrast output, bit for bit.\n   */\n  contrastLevel?: number | 'auto';\n  /** Per-theme seed overrides. */\n  themes?: {\n    success?: PaletteThemeSeed;\n    danger?: PaletteThemeSeed;\n    warning?: PaletteThemeSeed;\n    note?: PaletteThemeSeed;\n    code?: PaletteCodeSeed;\n  };\n}\n\n/** {@link PaletteConfig} with every field resolved to a concrete value. */\nexport interface ResolvedPaletteConfig {\n  hue: number;\n  baseHue: number;\n  saturation: number;\n  pastel: boolean;\n  contrastLevel: number | 'auto';\n  themes: {\n    success: { hue: number; saturation: number };\n    danger: { hue: number; saturation: number };\n    warning: { hue: number; saturation: number };\n    note: { hue: number; saturation: number };\n    code: { saturation: number };\n  };\n}\n\n// ============================================================================\n// Resolution\n// ============================================================================\n\nconst DEFAULT_THEME_HUES = {\n  success: DEFAULT_SUCCESS_HUE,\n  danger: DEFAULT_DANGER_HUE,\n  warning: DEFAULT_WARNING_HUE,\n  note: DEFAULT_NOTE_HUE,\n} as const;\n\nfunction resolveConfig(input: PaletteConfig): ResolvedPaletteConfig {\n  const saturation = input.saturation ?? DEFAULT_SATURATION;\n  const themes = input.themes ?? {};\n\n  const hue = input.hue ?? DEFAULT_HUE;\n\n  return {\n    hue,\n    baseHue: input.baseHue ?? hue,\n    saturation,\n    pastel: input.pastel ?? false,\n    contrastLevel: input.contrastLevel ?? 'auto',\n    themes: {\n      success: {\n        hue: themes.success?.hue ?? DEFAULT_THEME_HUES.success,\n        saturation: themes.success?.saturation ?? saturation,\n      },\n      danger: {\n        hue: themes.danger?.hue ?? DEFAULT_THEME_HUES.danger,\n        saturation: themes.danger?.saturation ?? saturation,\n      },\n      warning: {\n        hue: themes.warning?.hue ?? DEFAULT_THEME_HUES.warning,\n        saturation: themes.warning?.saturation ?? saturation,\n      },\n      note: {\n        hue: themes.note?.hue ?? DEFAULT_THEME_HUES.note,\n        saturation: themes.note?.saturation ?? saturation,\n      },\n      // Deliberately NOT `?? saturation`: the code palette is calibrated once and\n      // does not follow the palette-level seed. See `PaletteCodeSeed`.\n      code: { saturation: themes.code?.saturation ?? DEFAULT_SATURATION },\n    },\n  };\n}\n\n/**\n * The palette as it ships, with no tuning applied. Frozen — it is the baseline\n * every resolution falls back to, so a stray write to it would move the defaults\n * for the whole process.\n */\nexport const DEFAULT_PALETTE_CONFIG: ResolvedPaletteConfig = freezeConfig(\n  resolveConfig({}),\n);\n\n// ============================================================================\n// Store\n// ============================================================================\n\n/**\n * The last config *as written*, sparse — not the resolved one. Keeping the sparse\n * form is what makes inheritance live: a `saturation` with no `themes.danger.\n * saturation` beside it means danger genuinely follows the palette, rather than\n * having been frozen at whatever the palette read when it was set.\n */\nlet input: PaletteConfig = {};\nlet resolved: ResolvedPaletteConfig = DEFAULT_PALETTE_CONFIG;\nlet version = 0;\n\nconst listeners = new Set<() => void>();\n\nfunction mergeSeed<T extends PaletteThemeSeed | PaletteCodeSeed>(\n  base: T | undefined,\n  patch: T | undefined,\n): T | undefined {\n  if (!base) return patch;\n  // A patch that omits the theme entirely says nothing about it, so the base\n  // survives. Clearing one of its fields is `{ theme: { hue: undefined } }`.\n  if (!patch) return base;\n\n  return { ...base, ...patch };\n}\n\n/**\n * Layer a patch over a base config. Used by {@link resolvePaletteConfig} for\n * previews — *not* by {@link setPaletteConfig}, which replaces.\n */\nfunction mergeInput(base: PaletteConfig, patch: PaletteConfig): PaletteConfig {\n  const next: PaletteConfig = { ...base, ...patch };\n\n  if (base.themes || patch.themes) {\n    next.themes = {\n      success: mergeSeed(base.themes?.success, patch.themes?.success),\n      danger: mergeSeed(base.themes?.danger, patch.themes?.danger),\n      warning: mergeSeed(base.themes?.warning, patch.themes?.warning),\n      note: mergeSeed(base.themes?.note, patch.themes?.note),\n      code: mergeSeed(base.themes?.code, patch.themes?.code),\n    };\n  }\n\n  return next;\n}\n\nfunction isSameConfig(a: ResolvedPaletteConfig, b: ResolvedPaletteConfig) {\n  return (\n    a.hue === b.hue &&\n    a.baseHue === b.baseHue &&\n    a.saturation === b.saturation &&\n    a.pastel === b.pastel &&\n    a.contrastLevel === b.contrastLevel &&\n    a.themes.code.saturation === b.themes.code.saturation &&\n    (['success', 'danger', 'warning', 'note'] as const).every(\n      (name) =>\n        a.themes[name].hue === b.themes[name].hue &&\n        a.themes[name].saturation === b.themes[name].saturation,\n    )\n  );\n}\n\n/**\n * Which fields are *explicitly set*, as an order-independent signature.\n *\n * Two configs can resolve to identical values yet differ in which of those values\n * are pinned rather than inherited — pinning `primary.saturation` to the number it\n * already inherited is the obvious case. That difference is invisible to\n * {@link isSameConfig} but visible through {@link getPaletteConfigInput}, so it has\n * to count as a change or a settings UI reading it would never re-render.\n */\nfunction pinSignature(config: PaletteConfig): string {\n  const set = (value: unknown) => (value === undefined ? '0' : '1');\n\n  return [\n    set(config.hue),\n    set(config.baseHue),\n    set(config.saturation),\n    set(config.pastel),\n    set(config.contrastLevel),\n    set(config.themes?.code?.saturation),\n    ...(['success', 'danger', 'warning', 'note'] as const).flatMap((name) => [\n      set(config.themes?.[name]?.hue),\n      set(config.themes?.[name]?.saturation),\n    ]),\n  ].join('');\n}\n\n/**\n * Snapshot a config so the store owns it outright.\n *\n * Two hazards this closes. The caller's object stays theirs, so mutating it after\n * the call cannot desync `input` from `resolved`. And what we hand back from\n * {@link getPaletteConfig} / {@link getPaletteConfigInput} is frozen, so a caller\n * who writes to it gets a clear failure rather than silently corrupting the store\n * — the version would not bump, and every token cache would go on serving values\n * that no longer match the config.\n */\nfunction freezeConfig<T extends PaletteConfig | ResolvedPaletteConfig>(\n  config: T,\n): T {\n  const themes = config.themes;\n\n  if (themes) {\n    for (const seed of Object.values(themes)) {\n      if (seed) Object.freeze(seed);\n    }\n    Object.freeze(themes);\n  }\n\n  return Object.freeze(config);\n}\n\n/** {@link freezeConfig} on a copy, for a config we did not create ourselves. */\nfunction snapshotConfig(config: PaletteConfig): PaletteConfig {\n  const themes = config.themes;\n\n  return freezeConfig({\n    ...config,\n    ...(themes\n      ? {\n          themes: {\n            ...(themes.success ? { success: { ...themes.success } } : null),\n            ...(themes.danger ? { danger: { ...themes.danger } } : null),\n            ...(themes.warning ? { warning: { ...themes.warning } } : null),\n            ...(themes.note ? { note: { ...themes.note } } : null),\n            ...(themes.code ? { code: { ...themes.code } } : null),\n          },\n        }\n      : null),\n  });\n}\n\nfunction commit(nextInput: PaletteConfig) {\n  const nextResolved = resolveConfig(nextInput);\n\n  // Bail before bumping the version when nothing observable moved, so re-applying\n  // the same config — an inline `<Root palette={{ … }}>` literal on every\n  // render, a StrictMode double render — costs nothing.\n  if (\n    isSameConfig(resolved, nextResolved) &&\n    pinSignature(input) === pinSignature(nextInput)\n  ) {\n    return;\n  }\n\n  input = snapshotConfig(nextInput);\n  resolved = freezeConfig(nextResolved);\n  version++;\n\n  listeners.forEach((listener) => listener());\n}\n\n/**\n * Set the palette config.\n *\n * **Replaces**, like `useState` — the config you pass *is* the config, resolved\n * against the shipped defaults. Nothing accumulates, so a field you leave out is a\n * field you do not have: dropping a customization means dropping it from the\n * object, and re-applying the same object twice is the same as applying it once.\n *\n * ```ts\n * setPaletteConfig({ hue: 200, baseHue: 60 });\n * setPaletteConfig({ hue: 200 }); // baseHue is gone — back to inheriting `hue`\n * ```\n *\n * To adjust one field of the config already in place — a slider in a settings UI —\n * pass an updater. It receives the config as written, sparse, so spreading it\n * preserves which fields are pinned and which still inherit:\n *\n * ```ts\n * setPaletteConfig((config) => ({ ...config, hue: 200 }));\n * ```\n *\n * The palette is rebuilt lazily on the next token read, and any mounted `<Root>`\n * re-injects the token block — no component re-render is involved, because every\n * color in the kit resolves through a CSS custom property.\n */\nexport function setPaletteConfig(\n  config: PaletteConfig | ((previous: PaletteConfig) => PaletteConfig),\n): void {\n  commit(typeof config === 'function' ? config(input) : config);\n}\n\n/**\n * Drop all tuning and restore the palette the kit ships with. Identical to\n * `setPaletteConfig({})`; it exists to be readable at a call site.\n */\nexport function resetPaletteConfig(): void {\n  commit({});\n}\n\n/**\n * Force every token to re-resolve without changing the palette config.\n *\n * Only needed if you drive Glaze directly — `glaze.configure({ darkTone })` and\n * the like. Glaze invalidates its own caches, but the kit's token maps are\n * memoized against *this* module's version, so they need telling. Calling it\n * before the first paint is unnecessary; nothing has been resolved yet.\n */\nexport function invalidatePaletteTokens(): void {\n  version++;\n  listeners.forEach((listener) => listener());\n}\n\n/** The current config, with every field resolved to a concrete value. */\nexport function getPaletteConfig(): ResolvedPaletteConfig {\n  return resolved;\n}\n\n/**\n * The config **as set**, sparse — omitted fields are the ones still inheriting.\n *\n * {@link getPaletteConfig} resolves everything to concrete values, which loses the\n * distinction between \"explicitly 80\" and \"80 because it follows the brand\". A\n * settings UI needs that distinction to show an inherited value as inherited, and\n * to offer a way back:\n *\n * ```ts\n * const pinned = getPaletteConfigInput().baseHue !== undefined;\n *\n * // Re-link it to the brand by dropping the field.\n * setPaletteConfig(({ baseHue, ...config }) => config);\n * ```\n *\n * It is also the value handed to a {@link setPaletteConfig} updater.\n */\nexport function getPaletteConfigInput(): PaletteConfig {\n  return input;\n}\n\n/**\n * Resolve a patch **over** the current config, without applying it.\n *\n * This one layers, unlike {@link setPaletteConfig}: a preview wants \"the theme in\n * use, but in dark\", so the fields it does not mention have to come from the live\n * config rather than from the defaults. The store is not touched and no listener\n * fires.\n */\nexport function resolvePaletteConfig(\n  config?: PaletteConfig,\n): ResolvedPaletteConfig {\n  if (!config) return resolved;\n\n  return resolveConfig(mergeInput(input, config));\n}\n\n/**\n * Increments whenever the resolved config changes. The token caches in\n * `./palette.ts`, `./colors.ts` and `./index.ts` compare against it instead of\n * memoizing forever — the same idiom Glaze uses for its own config version.\n */\nexport function getPaletteVersion(): number {\n  return version;\n}\n\n/** Subscribe to palette config changes. Returns an unsubscribe function. */\nexport function subscribePaletteConfig(listener: () => void): () => void {\n  listeners.add(listener);\n\n  return () => {\n    listeners.delete(listener);\n  };\n}\n\n// ============================================================================\n// React bindings\n// ============================================================================\n\n/**\n * Re-render on palette config changes. Returns the version, not the config, so\n * the snapshot is a primitive and React never warns about an uncached snapshot.\n */\nexport function usePaletteVersion(): number {\n  return useSyncExternalStore(\n    subscribePaletteConfig,\n    getPaletteVersion,\n    getPaletteVersion,\n  );\n}\n\n/**\n * Read and tune the palette from React, `useState`-style — including the part\n * where the setter *replaces*. A control that changes one field wants the updater\n * form, or it will drop every other field:\n *\n * ```tsx\n * const [palette, setPalette] = usePaletteConfig();\n *\n * <HueSlider\n *   value={palette.hue}\n *   onChange={(hue) => setPalette((config) => ({ ...config, hue }))}\n * />\n * ```\n *\n * The first element is the *resolved* config, so `palette.hue` is always a number.\n * The updater's argument is the sparse one — see {@link getPaletteConfigInput}.\n *\n * The config is global process state, so every consumer of this hook — and every\n * mounted `<Root>` — sees the same palette.\n */\nexport function usePaletteConfig(): readonly [\n  ResolvedPaletteConfig,\n  typeof setPaletteConfig,\n] {\n  usePaletteVersion();\n\n  return [getPaletteConfig(), setPaletteConfig];\n}\n"],"mappings":"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"}

package/dist/tokens/palette.d.ts

@@ -1,7 +1,7 @@
 
 import { PaletteConfig } from "./palette-config.js";
 import { Styles, Tokens } from "@tenphi/tasty";
-import { GlazePalette, GlazeTheme } from "@tenphi/glaze";
+import { ColorMap, GlazePalette, GlazeTheme } from "@tenphi/glaze";
 
 //#region src/tokens/palette.d.ts
 /** Which resolved scheme variant {@link renderPaletteTokens} should return. */

package/dist/tokens/palette.js

@@ -1,4 +1,4 @@
-/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-7464463 | Cube Dev Team */
+/** @license MIT | @cube-dev/ui-kit v0.0.0-canary-a5d43c3 | Cube Dev Team */
 import { getPaletteConfig, getPaletteVersion, resolvePaletteConfig } from "./palette-config.js";
 import { lazyStyles } from "./lazy-styles.js";
 import { glaze } from "@tenphi/glaze";
@@ -198,6 +198,48 @@ const TINTED_SURFACE_OVERRIDE = {
 	}
 };
 /**
+* A tinted surface, a banding step, and text guaranteed to read on both.
+*
+* The recipe behind {@link getColorTheme} in `./color-theme.ts`, which builds
+* one-off themes at runtime from an arbitrary hue. It lives here so it shares
+* `TINTED_SURFACE_SATURATION`, the tone offsets and the text ramp with
+* {@link TINTED_SURFACE_OVERRIDE} above rather than forking them — a runtime tint
+* and a built-in theme's `surface` should be the same colour for the same hue.
+*
+* Three colours, because that is what banded, readable table column needs:
+* `surface` for even rows, `surface-2` one tone step down for odd rows and
+* pinned totals, and `surface-2-text`.
+*
+* The text is anchored to `surface-2`, not `surface`. `surface-2` has the lower
+* contrast headroom in BOTH schemes — a darker background under dark text in
+* light, a lighter one under light text in dark — so solving the floor there
+* clears it on both bands. The neutral ramp's own `surface-2-text` is shaped the
+* same way for the same reason.
+*/
+const TINT_RECIPE = {
+	surface: {
+		tone: [100 - TINTED_SURFACE_TONE_OFFSET, 100 - TINTED_SURFACE_TONE_OFFSET * 2],
+		saturation: TINTED_SURFACE_SATURATION
+	},
+	"surface-2": {
+		base: "surface",
+		tone: ["-2", "-4"],
+		saturation: TINTED_SURFACE_SATURATION
+	},
+	"surface-2-text": {
+		base: "surface-2",
+		tone: `${TEXT_TONE - TINTED_SURFACE_TONE_OFFSET - SURFACE_2_TEXT_OFFSET}`,
+		saturation: .25,
+		contrast: ["AA", "AAA"]
+	},
+	"surface-2-text-soft": {
+		base: "surface-2",
+		tone: `${TEXT_SOFT_TONE - TINTED_SURFACE_TONE_OFFSET - SURFACE_2_TEXT_OFFSET}`,
+		saturation: .25,
+		contrast: ["AA", "AAA"]
+	}
+};
+/**
 * Build the full palette from a resolved config.
 *
 * Pure: it reads nothing but its argument (and the global Glaze config, which
@@ -708,5 +750,5 @@ function renderPaletteTokens(options = {}) {
 const PALETTE_TOKENS = lazyStyles(getPaletteTokens);
 
 //#endregion
-export { PALETTE_TOKENS, getCodeTheme, getPalette, getPaletteTokens, renderPaletteTokens };
+export { PALETTE_TOKENS, TINT_RECIPE, getCodeTheme, getPalette, getPaletteTokens, renderPaletteTokens };
 //# sourceMappingURL=palette.js.map