@odla-ai/brand 0.1.0 → 0.2.1

package/dist/chunk-APLECQBR.js

@@ -0,0 +1,1010 @@
+// src/tokens/roles.ts
+var BRAND_REQUIRED_TOKENS = [
+  "--ui-bg",
+  "--ui-surface",
+  "--ui-surface-2",
+  "--ui-text",
+  "--ui-text-muted",
+  "--ui-text-faint",
+  "--ui-border",
+  "--ui-border-strong",
+  "--ui-accent",
+  "--ui-accent-strong",
+  "--ui-accent-soft",
+  "--ui-on-accent",
+  "--ui-good",
+  "--ui-good-soft",
+  "--ui-warn",
+  "--ui-warn-soft",
+  "--ui-danger",
+  "--ui-danger-soft",
+  "--ui-code-bg",
+  "--ui-code-text",
+  "--ui-shadow",
+  "--ui-font-sans",
+  "--ui-font-serif",
+  "--ui-font-mono",
+  "--ui-font-display"
+];
+var BRAND_DERIVED_TOKENS = [
+  "--ui-accent-glow",
+  "--ui-accent-2",
+  "--ui-accent-2-soft",
+  "--ui-highlight",
+  "--ui-focus",
+  "--ui-shadow-strong"
+];
+var BRAND_CHART_TOKENS = [
+  "--ui-chart-1",
+  "--ui-chart-2",
+  "--ui-chart-3",
+  "--ui-chart-4",
+  "--ui-chart-5",
+  "--ui-chart-6",
+  "--ui-chart-band",
+  "--ui-chart-band-strong",
+  "--ui-chart-flow",
+  "--ui-chart-glow"
+];
+var BRAND_CHAT_TOKENS = [
+  "--ui-chat-user-bg",
+  "--ui-chat-user-text",
+  "--ui-chat-assistant-bg",
+  "--ui-chat-thinking-bg",
+  "--ui-chat-thinking-text",
+  "--ui-chat-tool-accent"
+];
+var BRAND_EMITTED_TOKENS = [
+  ...BRAND_REQUIRED_TOKENS,
+  ...BRAND_DERIVED_TOKENS,
+  ...BRAND_CHART_TOKENS,
+  ...BRAND_CHAT_TOKENS
+];
+
+// src/color/hex.ts
+function clamp01(x) {
+  return Number.isNaN(x) ? 0 : x < 0 ? 0 : x > 1 ? 1 : x;
+}
+var HEX3 = /^#[0-9a-f]{3}$/;
+var HEX6 = /^#[0-9a-f]{6}$/;
+var HEX_ALPHA = /^#([0-9a-f]{4}|[0-9a-f]{8})$/;
+function parseHex(hex) {
+  const s = hex.trim().toLowerCase();
+  if (HEX_ALPHA.test(s)) {
+    throw new RangeError(
+      `parseHex: alpha hex "${hex}" is not supported \u2014 use an opaque "#rrggbb" value`
+    );
+  }
+  if (HEX3.test(s)) {
+    return {
+      r: parseInt(s[1] + s[1], 16) / 255,
+      g: parseInt(s[2] + s[2], 16) / 255,
+      b: parseInt(s[3] + s[3], 16) / 255
+    };
+  }
+  if (HEX6.test(s)) {
+    return {
+      r: parseInt(s.slice(1, 3), 16) / 255,
+      g: parseInt(s.slice(3, 5), 16) / 255,
+      b: parseInt(s.slice(5, 7), 16) / 255
+    };
+  }
+  throw new RangeError(`parseHex: expected "#rgb" or "#rrggbb", got "${hex}"`);
+}
+function toHex(rgb) {
+  const ch = (c) => Math.round(clamp01(c) * 255).toString(16).padStart(2, "0");
+  return `#${ch(rgb.r)}${ch(rgb.g)}${ch(rgb.b)}`;
+}
+function normalizeHex(hex) {
+  return toHex(parseHex(hex));
+}
+
+// src/color/convert.ts
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb(c) {
+  return c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055;
+}
+function rgbToHsl({ r, g, b }) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  const d = max - min;
+  if (d === 0) return { h: 0, s: 0, l };
+  const s = d / (1 - Math.abs(2 * l - 1));
+  let h;
+  if (max === r) h = 60 * ((g - b) / d % 6);
+  else if (max === g) h = 60 * ((b - r) / d + 2);
+  else h = 60 * ((r - g) / d + 4);
+  return { h: (h + 360) % 360, s, l };
+}
+function hslToRgb({ h, s, l }) {
+  const hue = (h % 360 + 360) % 360;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(hue / 60 % 2 - 1));
+  const m = l - c / 2;
+  const sextants = [
+    [c, x, 0],
+    [x, c, 0],
+    [0, c, x],
+    [0, x, c],
+    [x, 0, c],
+    [c, 0, x]
+  ];
+  const [r, g, b] = sextants[Math.floor(hue / 60) % 6];
+  return { r: r + m, g: g + m, b: b + m };
+}
+function rgbToOklab({ r, g, b }) {
+  const R = srgbToLinear(r);
+  const G = srgbToLinear(g);
+  const B = srgbToLinear(b);
+  const l = Math.cbrt(0.4122214708 * R + 0.5363325363 * G + 0.0514459929 * B);
+  const m = Math.cbrt(0.2119034982 * R + 0.6806995451 * G + 0.1073969566 * B);
+  const s = Math.cbrt(0.0883024619 * R + 0.2817188376 * G + 0.6299787005 * B);
+  return {
+    L: 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    a: 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    b: 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  };
+}
+function oklabToRgb({ L, a, b }) {
+  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  return {
+    r: linearToSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+    g: linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+    b: linearToSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s)
+  };
+}
+function oklabToOklch({ L, a, b }) {
+  const C = Math.hypot(a, b);
+  const h = C < 1e-9 ? 0 : (Math.atan2(b, a) * 180 / Math.PI + 360) % 360;
+  return { L, C, h };
+}
+function oklchToOklab({ L, C, h }) {
+  const rad = h * Math.PI / 180;
+  return { L, a: C * Math.cos(rad), b: C * Math.sin(rad) };
+}
+function hexToOklch(hex) {
+  return oklabToOklch(rgbToOklab(parseHex(hex)));
+}
+function oklchToHex(lch) {
+  return toHex(oklabToRgb(oklchToOklab(lch)));
+}
+var GAMUT_EPS = 1e-6;
+function inSrgbGamut({ r, g, b }) {
+  const ok = (c) => c >= -GAMUT_EPS && c <= 1 + GAMUT_EPS;
+  return ok(r) && ok(g) && ok(b);
+}
+function clampToGamut(lch) {
+  const L = clamp01(lch.L);
+  const h = lch.h;
+  if (inSrgbGamut(oklabToRgb(oklchToOklab({ L, C: lch.C, h })))) return { L, C: lch.C, h };
+  let lo = 0;
+  let hi = lch.C;
+  for (let i = 0; i < 24; i++) {
+    const mid = (lo + hi) / 2;
+    if (inSrgbGamut(oklabToRgb(oklchToOklab({ L, C: mid, h })))) lo = mid;
+    else hi = mid;
+  }
+  return { L, C: lo, h };
+}
+
+// src/color/contrast.ts
+function relativeLuminance(hex) {
+  const { r, g, b } = parseHex(hex);
+  return 0.2126 * srgbToLinear(r) + 0.7152 * srgbToLinear(g) + 0.0722 * srgbToLinear(b);
+}
+function contrastRatio(hexA, hexB) {
+  const la = relativeLuminance(hexA);
+  const lb = relativeLuminance(hexB);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+var AA = { text: 4.5, "large-text": 3, ui: 3 };
+var AAA = { text: 7, "large-text": 4.5 };
+function meetsAA(ratio, kind = "text") {
+  return ratio >= AA[kind];
+}
+function meetsAAA(ratio, kind = "text") {
+  return ratio >= AAA[kind];
+}
+var PICK_TEXT_DEFAULT_CANDIDATES = ["#ffffff", "#050505"];
+function pickTextOn(bgHex, candidates = PICK_TEXT_DEFAULT_CANDIDATES) {
+  if (candidates.length === 0) throw new RangeError("pickTextOn: candidates must be non-empty");
+  let best = candidates[0];
+  let bestRatio = -1;
+  for (const candidate of candidates) {
+    const ratio = contrastRatio(bgHex, candidate);
+    if (ratio > bestRatio) {
+      best = candidate;
+      bestRatio = ratio;
+    }
+  }
+  return best;
+}
+
+// src/color/harmony.ts
+function rotateHue(hex, degrees) {
+  const { L, C, h } = hexToOklch(hex);
+  return oklchToHex(clampToGamut({ L, C, h: ((h + degrees) % 360 + 360) % 360 }));
+}
+function complementary(hex) {
+  return rotateHue(hex, 180);
+}
+function analogous(hex, angle = 30) {
+  return [rotateHue(hex, -angle), rotateHue(hex, angle)];
+}
+function triadic(hex) {
+  return [rotateHue(hex, -120), rotateHue(hex, 120)];
+}
+function splitComplementary(hex) {
+  return [rotateHue(hex, -150), rotateHue(hex, 150)];
+}
+function tetradic(hex) {
+  return [rotateHue(hex, 90), rotateHue(hex, 180), rotateHue(hex, 270)];
+}
+function monochrome(hex, steps = 5) {
+  if (!Number.isInteger(steps) || steps < 2) {
+    throw new RangeError(`monochrome: steps must be an integer >= 2, got ${steps}`);
+  }
+  const { L, C, h } = hexToOklch(hex);
+  const out = [];
+  for (let i = 0; i < steps; i++) {
+    out.push(oklchToHex(clampToGamut({ L, C: C * (1 - i / (steps - 1)), h })));
+  }
+  return out;
+}
+
+// src/color/ramp.ts
+var RAMP_L_MAX = 0.96;
+var RAMP_L_MIN = 0.27;
+var CHROMA_FLOOR = 0.25;
+function tintShadeRamp(hex, steps = 9) {
+  if (!Number.isInteger(steps) || steps < 2) {
+    throw new RangeError(`tintShadeRamp: steps must be an integer >= 2, got ${steps}`);
+  }
+  const { C, h } = hexToOklch(hex);
+  const out = [];
+  for (let i = 0; i < steps; i++) {
+    const t = i / (steps - 1);
+    const L = RAMP_L_MAX + (RAMP_L_MIN - RAMP_L_MAX) * t;
+    const taper = CHROMA_FLOOR + (1 - CHROMA_FLOOR) * (1 - Math.abs(2 * t - 1));
+    out.push(oklchToHex(clampToGamut({ L, C: C * taper, h })));
+  }
+  return out;
+}
+var SCAN_STEPS = 16;
+var BISECT_STEPS = 22;
+function adjustLightnessUntil(hex, predicate, direction) {
+  const start = normalizeHex(hex);
+  if (predicate(start)) return start;
+  const { L, C, h } = hexToOklch(start);
+  const bound = direction === "lighten" ? 1 : 0;
+  const at = (l) => oklchToHex(clampToGamut({ L: l, C, h }));
+  let lastFail = L;
+  let firstPass = Number.NaN;
+  for (let i = 1; i <= SCAN_STEPS; i++) {
+    const l = L + (bound - L) * i / SCAN_STEPS;
+    if (predicate(at(l))) {
+      firstPass = l;
+      break;
+    }
+    lastFail = l;
+  }
+  if (Number.isNaN(firstPass)) return null;
+  for (let i = 0; i < BISECT_STEPS; i++) {
+    const mid = (lastFail + firstPass) / 2;
+    if (predicate(at(mid))) firstPass = mid;
+    else lastFail = mid;
+  }
+  return at(firstPass);
+}
+
+// src/color/delta.ts
+function deltaEOKLab(x, y) {
+  return Math.hypot(x.L - y.L, x.a - y.a, x.b - y.b);
+}
+function deltaEOK(hexA, hexB) {
+  return deltaEOKLab(rgbToOklab(parseHex(hexA)), rgbToOklab(parseHex(hexB)));
+}
+
+// src/color/names.ts
+var TABLE = [
+  ["aliceblue", "#f0f8ff"],
+  ["antiquewhite", "#faebd7"],
+  ["aqua", "#00ffff"],
+  ["aquamarine", "#7fffd4"],
+  ["azure", "#f0ffff"],
+  ["beige", "#f5f5dc"],
+  ["bisque", "#ffe4c4"],
+  ["black", "#000000"],
+  ["blanchedalmond", "#ffebcd"],
+  ["blue", "#0000ff"],
+  ["blueviolet", "#8a2be2"],
+  ["brown", "#a52a2a"],
+  ["burlywood", "#deb887"],
+  ["cadetblue", "#5f9ea0"],
+  ["chartreuse", "#7fff00"],
+  ["chocolate", "#d2691e"],
+  ["coral", "#ff7f50"],
+  ["cornflowerblue", "#6495ed"],
+  ["cornsilk", "#fff8dc"],
+  ["crimson", "#dc143c"],
+  ["cyan", "#00ffff"],
+  ["darkblue", "#00008b"],
+  ["darkcyan", "#008b8b"],
+  ["darkgoldenrod", "#b8860b"],
+  ["darkgray", "#a9a9a9"],
+  ["darkgreen", "#006400"],
+  ["darkgrey", "#a9a9a9"],
+  ["darkkhaki", "#bdb76b"],
+  ["darkmagenta", "#8b008b"],
+  ["darkolivegreen", "#556b2f"],
+  ["darkorange", "#ff8c00"],
+  ["darkorchid", "#9932cc"],
+  ["darkred", "#8b0000"],
+  ["darksalmon", "#e9967a"],
+  ["darkseagreen", "#8fbc8f"],
+  ["darkslateblue", "#483d8b"],
+  ["darkslategray", "#2f4f4f"],
+  ["darkslategrey", "#2f4f4f"],
+  ["darkturquoise", "#00ced1"],
+  ["darkviolet", "#9400d3"],
+  ["deeppink", "#ff1493"],
+  ["deepskyblue", "#00bfff"],
+  ["dimgray", "#696969"],
+  ["dimgrey", "#696969"],
+  ["dodgerblue", "#1e90ff"],
+  ["firebrick", "#b22222"],
+  ["floralwhite", "#fffaf0"],
+  ["forestgreen", "#228b22"],
+  ["fuchsia", "#ff00ff"],
+  ["gainsboro", "#dcdcdc"],
+  ["ghostwhite", "#f8f8ff"],
+  ["gold", "#ffd700"],
+  ["goldenrod", "#daa520"],
+  ["gray", "#808080"],
+  ["green", "#008000"],
+  ["greenyellow", "#adff2f"],
+  ["grey", "#808080"],
+  ["honeydew", "#f0fff0"],
+  ["hotpink", "#ff69b4"],
+  ["indianred", "#cd5c5c"],
+  ["indigo", "#4b0082"],
+  ["ivory", "#fffff0"],
+  ["khaki", "#f0e68c"],
+  ["lavender", "#e6e6fa"],
+  ["lavenderblush", "#fff0f5"],
+  ["lawngreen", "#7cfc00"],
+  ["lemonchiffon", "#fffacd"],
+  ["lightblue", "#add8e6"],
+  ["lightcoral", "#f08080"],
+  ["lightcyan", "#e0ffff"],
+  ["lightgoldenrodyellow", "#fafad2"],
+  ["lightgray", "#d3d3d3"],
+  ["lightgreen", "#90ee90"],
+  ["lightgrey", "#d3d3d3"],
+  ["lightpink", "#ffb6c1"],
+  ["lightsalmon", "#ffa07a"],
+  ["lightseagreen", "#20b2aa"],
+  ["lightskyblue", "#87cefa"],
+  ["lightslategray", "#778899"],
+  ["lightslategrey", "#778899"],
+  ["lightsteelblue", "#b0c4de"],
+  ["lightyellow", "#ffffe0"],
+  ["lime", "#00ff00"],
+  ["limegreen", "#32cd32"],
+  ["linen", "#faf0e6"],
+  ["magenta", "#ff00ff"],
+  ["maroon", "#800000"],
+  ["mediumaquamarine", "#66cdaa"],
+  ["mediumblue", "#0000cd"],
+  ["mediumorchid", "#ba55d3"],
+  ["mediumpurple", "#9370db"],
+  ["mediumseagreen", "#3cb371"],
+  ["mediumslateblue", "#7b68ee"],
+  ["mediumspringgreen", "#00fa9a"],
+  ["mediumturquoise", "#48d1cc"],
+  ["mediumvioletred", "#c71585"],
+  ["midnightblue", "#191970"],
+  ["mintcream", "#f5fffa"],
+  ["mistyrose", "#ffe4e1"],
+  ["moccasin", "#ffe4b5"],
+  ["navajowhite", "#ffdead"],
+  ["navy", "#000080"],
+  ["oldlace", "#fdf5e6"],
+  ["olive", "#808000"],
+  ["olivedrab", "#6b8e23"],
+  ["orange", "#ffa500"],
+  ["orangered", "#ff4500"],
+  ["orchid", "#da70d6"],
+  ["palegoldenrod", "#eee8aa"],
+  ["palegreen", "#98fb98"],
+  ["paleturquoise", "#afeeee"],
+  ["palevioletred", "#db7093"],
+  ["papayawhip", "#ffefd5"],
+  ["peachpuff", "#ffdab9"],
+  ["peru", "#cd853f"],
+  ["pink", "#ffc0cb"],
+  ["plum", "#dda0dd"],
+  ["powderblue", "#b0e0e6"],
+  ["purple", "#800080"],
+  ["rebeccapurple", "#663399"],
+  ["red", "#ff0000"],
+  ["rosybrown", "#bc8f8f"],
+  ["royalblue", "#4169e1"],
+  ["saddlebrown", "#8b4513"],
+  ["salmon", "#fa8072"],
+  ["sandybrown", "#f4a460"],
+  ["seagreen", "#2e8b57"],
+  ["seashell", "#fff5ee"],
+  ["sienna", "#a0522d"],
+  ["silver", "#c0c0c0"],
+  ["skyblue", "#87ceeb"],
+  ["slateblue", "#6a5acd"],
+  ["slategray", "#708090"],
+  ["slategrey", "#708090"],
+  ["snow", "#fffafa"],
+  ["springgreen", "#00ff7f"],
+  ["steelblue", "#4682b4"],
+  ["tan", "#d2b48c"],
+  ["teal", "#008080"],
+  ["thistle", "#d8bfd8"],
+  ["tomato", "#ff6347"],
+  ["turquoise", "#40e0d0"],
+  ["violet", "#ee82ee"],
+  ["wheat", "#f5deb3"],
+  ["white", "#ffffff"],
+  ["whitesmoke", "#f5f5f5"],
+  ["yellow", "#ffff00"],
+  ["yellowgreen", "#9acd32"]
+];
+var CSS_NAMED_COLORS = TABLE.map(([name, hex]) => ({
+  name,
+  hex
+}));
+var labCache = null;
+function nearestNamedColor(hex) {
+  const target = rgbToOklab(parseHex(hex));
+  labCache ??= TABLE.map(([, value2]) => rgbToOklab(parseHex(value2)));
+  let bestIdx = 0;
+  let bestD = Infinity;
+  for (let i = 0; i < labCache.length; i++) {
+    const d = deltaEOKLab(target, labCache[i]);
+    if (d < bestD) {
+      bestD = d;
+      bestIdx = i;
+    }
+  }
+  const [name, value] = TABLE[bestIdx];
+  return { name, hex: value, deltaEOK: bestD };
+}
+
+// src/color/palette.ts
+var CHART_DELTA_MIN = 0.1;
+var CHART_L = 0.7;
+var CHART_C = 0.115;
+var ANCHOR_HUE = 250;
+var ACHROMATIC_C = 0.02;
+var STATUS_HUES = { good: 145, warn: 85, danger: 25 };
+var STATUS_L = 0.7;
+var STATUS_C = 0.14;
+var ROTATIONS = [180, 120, -120, 150, -150];
+function deriveChartColors(seedHex, opts = {}) {
+  const count = opts.count ?? 6;
+  const deltaMin = opts.deltaMin ?? CHART_DELTA_MIN;
+  if (!Number.isInteger(count) || count < 1 || count > 12) {
+    throw new RangeError(`deriveChartColors: count must be an integer in 1..12, got ${count}`);
+  }
+  const lch = hexToOklch(normalizeHex(seedHex));
+  const base = lch.C < ACHROMATIC_C ? ANCHOR_HUE : lch.h;
+  const offsets = [0, 60, 120, 180, 240, 300, 30, 90, 150, 210, 270, 330];
+  const candidates = offsets.map(
+    (deg) => oklchToHex(clampToGamut({ L: CHART_L, C: CHART_C, h: (base + deg) % 360 }))
+  );
+  const picked = [];
+  for (const hex of candidates) {
+    if (picked.length >= count) break;
+    if (picked.includes(hex)) continue;
+    if (picked.every((p) => deltaEOK(p, hex) >= deltaMin)) picked.push(hex);
+  }
+  for (const hex of candidates) {
+    if (picked.length >= count) break;
+    if (!picked.includes(hex)) picked.push(hex);
+  }
+  return picked;
+}
+function derivePalette(seedHex, opts = {}) {
+  const withNames = opts.names !== false;
+  const seed = normalizeHex(seedHex);
+  const seedLch = hexToOklch(seed);
+  const achromatic = seedLch.C < ACHROMATIC_C;
+  const hue = achromatic ? ANCHOR_HUE : seedLch.h;
+  const neutralAt = (L, C) => oklchToHex(clampToGamut({ L, C, h: hue }));
+  const bg = neutralAt(0.985, 5e-3);
+  const surface = neutralAt(0.955, 8e-3);
+  const text = neutralAt(0.24, 0.012);
+  const neutral = neutralAt(0.62, 0.012);
+  const accentBase = achromatic ? oklchToHex(
+    clampToGamut({ L: Math.min(Math.max(seedLch.L, 0.45), 0.75), C: CHART_C, h: ANCHOR_HUE })
+  ) : seed;
+  const cands = ROTATIONS.map((deg) => {
+    const hex = rotateHue(accentBase, deg);
+    return { deg, hex, d: deltaEOK(seed, hex) };
+  });
+  let secondary = cands[0];
+  for (const c of cands) if (c.d > secondary.d) secondary = c;
+  let highlight = cands[0] === secondary ? cands[1] : cands[0];
+  let hiScore = Math.min(highlight.d, deltaEOK(highlight.hex, secondary.hex));
+  for (const c of cands) {
+    if (c === secondary || c === highlight) continue;
+    const score = Math.min(c.d, deltaEOK(c.hex, secondary.hex));
+    if (score > hiScore) {
+      highlight = c;
+      hiScore = score;
+    }
+  }
+  const status = (anchor) => {
+    const start = oklchToHex(clampToGamut({ L: STATUS_L, C: STATUS_C, h: anchor }));
+    return adjustLightnessUntil(start, (c) => contrastRatio(c, bg) >= 3, "darken") ?? text;
+  };
+  const sw = (role, hex, rationale) => ({
+    role,
+    hex,
+    rationale
+  });
+  const swatches = [
+    sw("primary", seed, "seed color"),
+    sw("secondary", secondary.hex, `harmony rotation ${secondary.deg}\xB0, \u0394EOK ${secondary.d.toFixed(3)} from primary`),
+    sw("highlight", highlight.hex, `harmony rotation ${highlight.deg}\xB0, spread from primary and secondary`),
+    sw("good", status(STATUS_HUES.good), "green anchor 145\xB0, \u22653:1 on bg"),
+    sw("warn", status(STATUS_HUES.warn), "amber anchor 85\xB0, \u22653:1 on bg"),
+    sw("danger", status(STATUS_HUES.danger), "red anchor 25\xB0, \u22653:1 on bg"),
+    sw("bg", bg, "near-white tinted with the seed hue"),
+    sw("surface", surface, "raised surface, one step below bg"),
+    sw("text", text, "near-black tinted with the seed hue"),
+    sw("neutral", neutral, "mid neutral for borders and muted marks"),
+    ...deriveChartColors(seed).map((hex, i) => sw("chart", hex, `chart series ${i + 1}`))
+  ];
+  return withNames ? swatches.map((s) => ({ ...s, name: nearestNamedColor(s.hex).name })) : swatches;
+}
+
+// src/tokens/map.ts
+var DEFAULT_ACCENT_SEED = "#3b5e8c";
+var CHROMATIC_C = 0.02;
+var SANS_STACK = `ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif`;
+var SERIF_STACK = `"Iowan Old Style", "Palatino Linotype", Palatino, Georgia, serif`;
+var MONO_STACK = `ui-monospace, "SF Mono", Menlo, Consolas, monospace`;
+var DISPLAY_STACK = `ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif`;
+var UI_CHART_DEFAULTS = [
+  "var(--ui-accent)",
+  "var(--ui-good)",
+  "var(--ui-warn)",
+  "var(--ui-danger)",
+  "color-mix(in srgb, var(--ui-accent) 45%, var(--ui-text))",
+  "var(--ui-text-faint)"
+];
+var ROLE_TOKEN = {
+  primary: "--ui-accent",
+  secondary: "--ui-accent-2",
+  highlight: "--ui-highlight",
+  bg: "--ui-bg",
+  surface: "--ui-surface",
+  text: "--ui-text",
+  neutral: "--ui-border-strong",
+  good: "--ui-good",
+  warn: "--ui-warn",
+  danger: "--ui-danger",
+  chart: "--ui-chart-1"
+};
+var mixVar = (name, pct) => `color-mix(in srgb, var(${name}) ${pct}%, transparent)`;
+function shiftL(hex, dL) {
+  const { L, C, h } = hexToOklch(hex);
+  return oklchToHex(clampToGamut({ L: clamp01(L + dL), C, h }));
+}
+function lerpL(fromHex, toHex2, t) {
+  const a = hexToOklch(fromHex);
+  const b = hexToOklch(toHex2);
+  return oklchToHex(clampToGamut({ L: a.L + (b.L - a.L) * t, C: a.C, h: a.h }));
+}
+function ensureOnBg(hex, bg, min) {
+  const pred = (c) => contrastRatio(c, bg) >= min;
+  const away = relativeLuminance(bg) >= relativeLuminance(hex) ? "darken" : "lighten";
+  return adjustLightnessUntil(hex, pred, away) ?? adjustLightnessUntil(hex, pred, away === "darken" ? "lighten" : "darken") ?? pickTextOn(bg);
+}
+var rgbaOf = (hex, alpha) => {
+  const { r, g, b } = parseHex(hex);
+  const c = (v) => Math.round(v * 255);
+  return `rgba(${c(r)}, ${c(g)}, ${c(b)}, ${alpha})`;
+};
+function fontValue(family, stack) {
+  const f = family?.trim() ?? "";
+  if (f === "") return stack;
+  if (f.includes(",") || /^["']/.test(f) || /^[a-zA-Z][a-zA-Z0-9-]*$/.test(f))
+    return `${f}, ${stack}`;
+  return `"${f.replaceAll('"', "")}", ${stack}`;
+}
+function collect(swatches, warnings) {
+  const byRole = {};
+  const charts = [];
+  if (!Array.isArray(swatches)) {
+    warnings.push({ token: "--ui-accent", message: "swatches is not an array; compiling from defaults" });
+    return { byRole, charts };
+  }
+  swatches.forEach((s, i) => {
+    let hex;
+    try {
+      hex = normalizeHex(String(s?.hex));
+    } catch {
+      warnings.push({
+        token: s?.role !== void 0 && ROLE_TOKEN[s.role] || "--ui-accent",
+        message: `swatches[${i}] dropped: invalid hex ${String(s?.hex)}`
+      });
+      return;
+    }
+    const role = s?.role;
+    if (role === "chart") charts.push(hex);
+    else if (role !== void 0 && role !== "custom" && byRole[role] === void 0) byRole[role] = hex;
+  });
+  return { byRole, charts };
+}
+function mapPaletteToTokens(input) {
+  const warnings = [];
+  const { byRole, charts } = collect(input?.swatches, warnings);
+  let accent = byRole.primary;
+  if (accent === void 0) {
+    const chromatic = [...Object.values(byRole), ...charts].find(
+      (h) => h !== void 0 && hexToOklch(h).C >= CHROMATIC_C
+    );
+    accent = chromatic ?? DEFAULT_ACCENT_SEED;
+    warnings.push({
+      token: "--ui-accent",
+      message: `no primary swatch; using ${chromatic !== void 0 ? "the first chromatic swatch" : "the neutral default seed"} ${accent}`
+    });
+  }
+  const fb = /* @__PURE__ */ new Map();
+  for (const s of derivePalette(accent, { names: false })) if (!fb.has(s.role)) fb.set(s.role, s.hex);
+  const pick = (role) => {
+    const own = byRole[role];
+    if (own !== void 0) return own;
+    const derived = fb.get(role);
+    warnings.push({ token: ROLE_TOKEN[role], message: `no ${role} swatch; derived ${derived} from ${accent}` });
+    return derived;
+  };
+  const bg = pick("bg");
+  const surface = pick("surface");
+  const neutral = pick("neutral");
+  const surface2 = shiftL(surface, -0.035);
+  const rawText = pick("text");
+  const text = ensureOnBg(rawText, bg, 4.5);
+  if (text !== rawText)
+    warnings.push({ token: "--ui-text", message: "adjusted to reach 4.5:1 on --ui-bg", adjustedFrom: rawText });
+  const accentStrong = ensureOnBg(accent, bg, 4.5);
+  if (accentStrong !== accent)
+    warnings.push({
+      token: "--ui-accent-strong",
+      message: "moved --ui-accent in lightness to reach 4.5:1 on --ui-bg",
+      adjustedFrom: accent
+    });
+  const status = (role) => {
+    const own = pick(role);
+    const fixed = ensureOnBg(own, bg, 3);
+    if (fixed !== own)
+      warnings.push({ token: ROLE_TOKEN[role], message: "adjusted to reach 3:1 on --ui-bg", adjustedFrom: own });
+    return fixed;
+  };
+  const chromaticCharts = charts.filter((h) => hexToOklch(h).C >= CHROMATIC_C);
+  let chartValues;
+  if (chromaticCharts.length >= 3) {
+    const picked = chromaticCharts.slice(0, 6);
+    for (const c of deriveChartColors(accent, { count: 12 })) {
+      if (picked.length >= 6) break;
+      if (!picked.includes(c)) picked.push(c);
+    }
+    chartValues = picked;
+  } else {
+    warnings.push({
+      token: "--ui-chart-1",
+      message: `fewer than 3 chromatic chart swatches (${chromaticCharts.length}); using the ui derived chart defaults`
+    });
+    chartValues = UI_CHART_DEFAULTS;
+  }
+  const secondary = byRole.secondary;
+  if (secondary === void 0)
+    warnings.push({ token: "--ui-accent-2", message: "no secondary swatch; --ui-accent-2 collapses onto var(--ui-accent) (ui default)" });
+  const highlight = byRole.highlight;
+  if (highlight === void 0)
+    warnings.push({ token: "--ui-highlight", message: "no highlight swatch; --ui-highlight aliases var(--ui-accent-strong) (ui default)" });
+  const t = input?.typography ?? {};
+  const tokens = {
+    "--ui-bg": bg,
+    "--ui-surface": surface,
+    "--ui-surface-2": surface2,
+    "--ui-text": text,
+    "--ui-text-muted": ensureOnBg(lerpL(text, bg, 0.35), bg, 4.5),
+    "--ui-text-faint": lerpL(text, bg, 0.58),
+    "--ui-border": lerpL(neutral, bg, 0.55),
+    "--ui-border-strong": neutral,
+    "--ui-accent": accent,
+    "--ui-accent-strong": accentStrong,
+    "--ui-accent-soft": mixVar("--ui-accent", 10),
+    "--ui-on-accent": pickTextOn(accent),
+    "--ui-good": status("good"),
+    "--ui-good-soft": mixVar("--ui-good", 12),
+    "--ui-warn": status("warn"),
+    "--ui-warn-soft": mixVar("--ui-warn", 12),
+    "--ui-danger": status("danger"),
+    "--ui-danger-soft": mixVar("--ui-danger", 10),
+    "--ui-code-bg": surface2,
+    "--ui-code-text": text,
+    "--ui-shadow": `0 1px 2px ${rgbaOf(text, 0.04)}, 0 8px 24px ${rgbaOf(text, 0.06)}`,
+    "--ui-font-sans": fontValue(t.fontBody, SANS_STACK),
+    "--ui-font-serif": SERIF_STACK,
+    "--ui-font-mono": fontValue(t.fontMono, MONO_STACK),
+    "--ui-font-display": fontValue(t.fontDisplay ?? t.fontBody, DISPLAY_STACK),
+    "--ui-accent-glow": mixVar("--ui-accent", 16),
+    "--ui-accent-2": secondary ?? "var(--ui-accent)",
+    "--ui-accent-2-soft": mixVar("--ui-accent-2", 10),
+    "--ui-highlight": highlight ?? "var(--ui-accent-strong)",
+    "--ui-focus": "0 0 0 3px var(--ui-accent-soft)",
+    "--ui-shadow-strong": "var(--ui-shadow)",
+    "--ui-chart-1": chartValues[0],
+    "--ui-chart-2": chartValues[1],
+    "--ui-chart-3": chartValues[2],
+    "--ui-chart-4": chartValues[3],
+    "--ui-chart-5": chartValues[4],
+    "--ui-chart-6": chartValues[5],
+    "--ui-chart-band": mixVar("--ui-accent", 10),
+    "--ui-chart-band-strong": mixVar("--ui-accent", 22),
+    "--ui-chart-flow": "var(--ui-accent)",
+    "--ui-chart-glow": "var(--ui-accent-strong)",
+    "--ui-chat-user-bg": "var(--ui-accent-soft)",
+    "--ui-chat-user-text": "var(--ui-text)",
+    "--ui-chat-assistant-bg": "var(--ui-surface)",
+    "--ui-chat-thinking-bg": "var(--ui-surface-2)",
+    "--ui-chat-thinking-text": "var(--ui-text-muted)",
+    "--ui-chat-tool-accent": "var(--ui-accent)"
+  };
+  return { tokens, warnings };
+}
+
+// src/tokens/dark.ts
+var DARK_FLIP_L_MIN = 0.2;
+var DARK_FLIP_L_MAX = 0.95;
+var DARK_SHADOW = "0 1px 2px rgba(0, 0, 0, 0.3), 0 8px 24px rgba(0, 0, 0, 0.35)";
+var HEX62 = /^#[0-9a-f]{6}$/;
+var NEUTRAL_FLIP = /* @__PURE__ */ new Set([
+  "--ui-bg",
+  "--ui-surface",
+  "--ui-surface-2",
+  "--ui-text",
+  "--ui-text-muted",
+  "--ui-text-faint",
+  "--ui-border",
+  "--ui-border-strong",
+  "--ui-code-bg",
+  "--ui-code-text"
+]);
+var MIN_RUNG = 0.02;
+var ACCENT_AA = [
+  "--ui-accent",
+  "--ui-accent-strong",
+  "--ui-accent-2",
+  "--ui-highlight",
+  "--ui-good",
+  "--ui-warn",
+  "--ui-danger"
+];
+var CHART_UI = [
+  "--ui-chart-1",
+  "--ui-chart-2",
+  "--ui-chart-3",
+  "--ui-chart-4",
+  "--ui-chart-5",
+  "--ui-chart-6"
+];
+function flipNeutral(hex) {
+  const { L, C, h } = hexToOklch(hex);
+  const flipped = DARK_FLIP_L_MIN + (1 - L) * (DARK_FLIP_L_MAX - DARK_FLIP_L_MIN);
+  return oklchToHex(clampToGamut({ L: flipped, C, h }));
+}
+function rebuildSurfaces(out, light, lightBgL, darkBgL) {
+  const lightSurface = light["--ui-surface"];
+  const lightSurface2 = light["--ui-surface-2"];
+  let surfaceDarkL;
+  let surfaceLightL = lightBgL;
+  if (lightSurface !== void 0 && HEX62.test(lightSurface)) {
+    const { L, C, h } = hexToOklch(lightSurface);
+    surfaceLightL = L;
+    surfaceDarkL = darkBgL + Math.max(Math.abs(L - lightBgL), MIN_RUNG);
+    out["--ui-surface"] = oklchToHex(clampToGamut({ L: surfaceDarkL, C, h }));
+  }
+  if (lightSurface2 !== void 0 && HEX62.test(lightSurface2)) {
+    const { L, C, h } = hexToOklch(lightSurface2);
+    const base = surfaceDarkL ?? darkBgL + MIN_RUNG;
+    const L2 = base + Math.max(Math.abs(L - surfaceLightL), MIN_RUNG);
+    out["--ui-surface-2"] = oklchToHex(clampToGamut({ L: L2, C, h }));
+  }
+  const lightCodeBg = light["--ui-code-bg"];
+  if (lightCodeBg !== void 0 && HEX62.test(lightCodeBg)) {
+    if (lightCodeBg === lightSurface2 && out["--ui-surface-2"] !== void 0) {
+      out["--ui-code-bg"] = out["--ui-surface-2"];
+    } else {
+      const { L, C, h } = hexToOklch(lightCodeBg);
+      const codeL = darkBgL + Math.max(Math.abs(L - lightBgL), MIN_RUNG);
+      out["--ui-code-bg"] = oklchToHex(clampToGamut({ L: codeL, C, h }));
+    }
+  }
+}
+function relight(hex, bg, min) {
+  const pred = (c) => contrastRatio(c, bg) >= min;
+  return adjustLightnessUntil(hex, pred, "lighten") ?? adjustLightnessUntil(hex, pred, "darken") ?? pickTextOn(bg);
+}
+function deriveDarkTokens(light) {
+  const out = {};
+  for (const [name, value] of Object.entries(light)) {
+    if (name === "--ui-shadow") out[name] = DARK_SHADOW;
+    else if (NEUTRAL_FLIP.has(name) && HEX62.test(value)) out[name] = flipNeutral(value);
+    else out[name] = value;
+  }
+  const bg = out["--ui-bg"];
+  const lightBg = light["--ui-bg"];
+  if (bg === void 0 || !HEX62.test(bg) || lightBg === void 0 || !HEX62.test(lightBg)) return out;
+  rebuildSurfaces(out, light, hexToOklch(lightBg).L, hexToOklch(bg).L);
+  for (const name of ["--ui-text", "--ui-text-muted"]) {
+    const v = out[name];
+    if (v !== void 0 && HEX62.test(v)) out[name] = relight(v, bg, 4.5);
+  }
+  const codeBg = out["--ui-code-bg"];
+  const codeText = out["--ui-code-text"];
+  if (codeText !== void 0 && HEX62.test(codeText))
+    out["--ui-code-text"] = relight(codeText, codeBg !== void 0 && HEX62.test(codeBg) ? codeBg : bg, 4.5);
+  for (const name of ACCENT_AA) {
+    const v = out[name];
+    if (v !== void 0 && HEX62.test(v)) out[name] = relight(v, bg, 4.5);
+  }
+  for (const name of CHART_UI) {
+    const v = out[name];
+    if (v !== void 0 && HEX62.test(v)) out[name] = relight(v, bg, 3);
+  }
+  const accent = out["--ui-accent"];
+  const onAccent = out["--ui-on-accent"];
+  if (accent !== void 0 && HEX62.test(accent) && onAccent !== void 0 && HEX62.test(onAccent))
+    out["--ui-on-accent"] = pickTextOn(accent);
+  return out;
+}
+
+// src/tokens/css.ts
+var HEADER = "/* Generated by @odla-ai/brand \u2014 @odla-ai/ui token overrides; pair with @odla-ai/ui css/tokens.css. */";
+var ORDER = new Map(
+  BRAND_EMITTED_TOKENS.map((name, i) => [name, i])
+);
+function orderedNames(tokens) {
+  return Object.keys(tokens).sort((a, b) => {
+    const ia = ORDER.get(a);
+    const ib = ORDER.get(b);
+    if (ia !== void 0 && ib !== void 0) return ia - ib;
+    if (ia !== void 0) return -1;
+    if (ib !== void 0) return 1;
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+}
+function renderBlock(selector, tokens, names, indent, lead) {
+  const lines = [];
+  if (lead !== void 0) lines.push(`${indent}  ${lead}`);
+  for (const name of names) lines.push(`${indent}  ${name}: ${tokens[name]};`);
+  if (lines.length === 0) return `${indent}${selector} {
+${indent}}`;
+  return `${indent}${selector} {
+${lines.join("\n")}
+${indent}}`;
+}
+function renderTokensCss(light, opts = {}) {
+  const selector = opts.selector ?? ":root";
+  const scoped = selector !== ":root";
+  const parts = [HEADER, renderBlock(selector, light, orderedNames(light), "")];
+  const dark = opts.dark;
+  if (dark !== void 0) {
+    const diffNames = orderedNames(dark).filter((name) => light[name] !== dark[name]);
+    if (diffNames.length > 0) {
+      const attrSelector = scoped ? `[data-theme="dark"] ${selector}, ${selector}[data-theme="dark"]` : `[data-theme="dark"]`;
+      const mediaSelector = scoped ? `:root:not([data-theme="light"]) ${selector}` : `:root:not([data-theme="light"])`;
+      parts.push(renderBlock(attrSelector, dark, diffNames, ""));
+      parts.push(
+        `@media (prefers-color-scheme: dark) {
+${renderBlock(mediaSelector, dark, diffNames, "  ")}
+}`
+      );
+    }
+    if (opts.includeInvert === true) {
+      parts.push(renderBlock(".ui-invert", dark, orderedNames(dark), "", "color-scheme: dark;"));
+    }
+  }
+  return `${parts.join("\n\n")}
+`;
+}
+
+// src/tokens/compile.ts
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function applyOverrides(light, overrides, warnings) {
+  if (overrides === void 0) return;
+  if (!isRecord(overrides)) {
+    warnings.push({ token: "--ui-accent", message: "overrides ignored: not an object" });
+    return;
+  }
+  for (const [name, value] of Object.entries(overrides)) {
+    if (!name.startsWith("--")) {
+      warnings.push({ token: name, message: "override ignored: token names must start with --" });
+      continue;
+    }
+    if (typeof value !== "string" || value.trim() === "") {
+      warnings.push({ token: name, message: "override ignored: value must be a non-empty string" });
+      continue;
+    }
+    light[name] = value.trim();
+  }
+}
+function compileBrandTokens(input) {
+  const { tokens: light, warnings } = mapPaletteToTokens(input);
+  applyOverrides(light, input?.overrides, warnings);
+  const dark = deriveDarkTokens(light);
+  return { light, dark, warnings };
+}
+
+export {
+  clamp01,
+  parseHex,
+  toHex,
+  normalizeHex,
+  srgbToLinear,
+  linearToSrgb,
+  rgbToHsl,
+  hslToRgb,
+  rgbToOklab,
+  oklabToRgb,
+  oklabToOklch,
+  oklchToOklab,
+  hexToOklch,
+  oklchToHex,
+  inSrgbGamut,
+  clampToGamut,
+  relativeLuminance,
+  contrastRatio,
+  meetsAA,
+  meetsAAA,
+  PICK_TEXT_DEFAULT_CANDIDATES,
+  pickTextOn,
+  rotateHue,
+  complementary,
+  analogous,
+  triadic,
+  splitComplementary,
+  tetradic,
+  monochrome,
+  RAMP_L_MAX,
+  RAMP_L_MIN,
+  tintShadeRamp,
+  adjustLightnessUntil,
+  deltaEOKLab,
+  deltaEOK,
+  CSS_NAMED_COLORS,
+  nearestNamedColor,
+  CHART_DELTA_MIN,
+  deriveChartColors,
+  derivePalette,
+  BRAND_REQUIRED_TOKENS,
+  BRAND_DERIVED_TOKENS,
+  BRAND_CHART_TOKENS,
+  BRAND_CHAT_TOKENS,
+  BRAND_EMITTED_TOKENS,
+  DEFAULT_ACCENT_SEED,
+  mapPaletteToTokens,
+  DARK_FLIP_L_MIN,
+  DARK_FLIP_L_MAX,
+  deriveDarkTokens,
+  renderTokensCss,
+  compileBrandTokens
+};
+//# sourceMappingURL=chunk-APLECQBR.js.map