@trishchuk/coolors-mcp 1.0.0 → 1.1.0

package/dist/bin/server.js

@@ -1,30 +1,658 @@
 #!/usr/bin/env node
 import {
   CoolorsMcp
-} from "../chunk-IQ7NN26V.js";
+} from "../chunk-LHW2ZTOU.js";
 import {
   DislikeAnalyzer,
   Hct,
   TonalPalette,
   adjustTemperature,
+  argbToRgb,
   blend,
   colorDistance,
   corePaletteFromRgb,
+  darken,
+  desaturate,
   getContrastRatio,
   harmonize,
   hexToRgb,
   hslToRgb,
+  invertColor,
   labToRgb,
+  lighten,
+  mixColors,
   parseColor,
   rgbToArgb,
   rgbToHct,
   rgbToHex,
   rgbToHsl,
-  rgbToLab
-} from "../chunk-P3ARRKLS.js";
+  rgbToLab,
+  saturate,
+  toGrayscale
+} from "../chunk-HOMDMKUY.js";
 
-// src/tools/color-conversion.tool.ts
+// src/tools/adjust-color.tool.ts
 import { z } from "zod";
+var OPS = [
+  "lighten",
+  "darken",
+  "saturate",
+  "desaturate",
+  "grayscale",
+  "invert",
+  "mix"
+];
+var adjustColorTool = {
+  description: "Adjust a color: lighten, darken, saturate, desaturate, grayscale, invert, or mix with a second color. Amount is 0-100 (percent) for lighten/darken/saturate/desaturate, 0-1 for mix weight.",
+  execute: async (args) => {
+    const rgb = parseColor(args.color);
+    if (!rgb) return `Invalid color format: ${args.color}`;
+    switch (args.operation) {
+      case "darken":
+        return rgbToHex(darken(rgb, args.amount ?? 10));
+      case "desaturate":
+        return rgbToHex(desaturate(rgb, args.amount ?? 10));
+      case "grayscale":
+        return rgbToHex(toGrayscale(rgb));
+      case "invert":
+        return rgbToHex(invertColor(rgb));
+      case "lighten":
+        return rgbToHex(lighten(rgb, args.amount ?? 10));
+      case "mix": {
+        if (!args.with) return "Error: 'with' is required for mix operation";
+        const other = parseColor(args.with);
+        if (!other) return `Invalid color format: ${args.with}`;
+        const weight = args.amount ?? 0.5;
+        if (weight < 0 || weight > 1) {
+          return "Error: mix amount must be between 0 and 1";
+        }
+        return rgbToHex(mixColors(rgb, other, weight));
+      }
+      case "saturate":
+        return rgbToHex(saturate(rgb, args.amount ?? 10));
+    }
+  },
+  name: "adjust_color",
+  parameters: z.object({
+    amount: z.number().optional().describe(
+      "Amount of change. For lighten/darken/saturate/desaturate: 0-100 (percent). For mix: 0-1 (weight of first color). Default 10 / 0.5."
+    ),
+    color: z.string().describe("Color to adjust (hex, rgb, hsl)"),
+    operation: z.enum(OPS).describe("Adjustment operation"),
+    with: z.string().optional().describe("Second color (only for mix)")
+  })
+};
+
+// src/tools/cohesion.tools.ts
+import { z as z2 } from "zod";
+var TONAL_STOPS = [
+  50,
+  100,
+  200,
+  300,
+  400,
+  500,
+  600,
+  700,
+  800,
+  900,
+  950
+];
+function hctFromColor(input) {
+  const rgb = parseColor(input);
+  if (!rgb) return null;
+  return Hct.fromInt(rgbToArgb(rgb));
+}
+function hctToHex(h, c, t) {
+  const hct = Hct.from(h, c, t);
+  return rgbToHex(argbToRgb(hct.toInt()));
+}
+var generateTonalScaleTool = {
+  description: "Generate a complete tonal scale (Tailwind-style 50/100/.../900/950) from a seed color. Uses Google's HCT color space so each step is perceptually even \u2014 ideal for building shadable design-system colors.",
+  execute: async (args) => {
+    const hct = hctFromColor(args.seed);
+    if (!hct) return `Invalid color format: ${args.seed}`;
+    const stops = args.stops?.length ? args.stops : Array.from(TONAL_STOPS);
+    const chromaBoost = args.chromaBoost ?? 1;
+    const name = (args.name ?? "color").toLowerCase();
+    const tones = stops.map((s) => Math.max(0, Math.min(100, 100 - s / 10)));
+    let output = `# Tonal scale for ${args.seed}
+`;
+    output += `Seed HCT: H=${hct.hue.toFixed(1)}\xB0 C=${hct.chroma.toFixed(1)} T=${hct.tone.toFixed(1)}
+
+`;
+    output += `| stop | tone | hex |
+|---|---|---|
+`;
+    const rows = [];
+    for (let i = 0; i < stops.length; i++) {
+      const tone = tones[i];
+      const edge = Math.abs(50 - tone) / 50;
+      const chroma = hct.chroma * chromaBoost * (1 - 0.35 * edge);
+      const hex = hctToHex(hct.hue, chroma, tone);
+      rows.push({ hex, stop: stops[i], tone });
+      output += `| ${stops[i]} | ${tone.toFixed(0)} | ${hex} |
+`;
+    }
+    output += `
+## CSS
+\`\`\`css
+:root {
+`;
+    for (const r of rows) output += `  --${name}-${r.stop}: ${r.hex};
+`;
+    output += `}
+\`\`\`
+`;
+    return output;
+  },
+  name: "generate_tonal_scale",
+  parameters: z2.object({
+    chromaBoost: z2.number().min(0).max(2).optional().default(1).describe("Multiplier on seed chroma (1 = preserve, <1 = muted)"),
+    name: z2.string().optional().describe("CSS variable base name (default: 'color')"),
+    seed: z2.string().describe("Seed color (hex, rgb, hsl)"),
+    stops: z2.array(z2.number().min(0).max(1e3)).optional().describe(
+      "Custom stops. Default: [50,100,200,300,400,500,600,700,800,900,950]."
+    )
+  })
+};
+var generateStateColorsTool = {
+  description: "Generate consistent interaction-state colors (hover / active / pressed / focus / disabled / selected) from a base color. Steps are computed in HCT space so they keep equal perceptual weight regardless of base hue.",
+  execute: async (args) => {
+    const hct = hctFromColor(args.base);
+    if (!hct) return `Invalid color format: ${args.base}`;
+    const dark = args.isDark ?? false;
+    const dir = dark ? 1 : -1;
+    const states = [
+      { hex: "", note: "resting", state: "base", tone: hct.tone },
+      {
+        hex: "",
+        note: "+/- 8 tone",
+        state: "hover",
+        tone: hct.tone + dir * 8
+      },
+      {
+        hex: "",
+        note: "+/- 16 tone",
+        state: "active",
+        tone: hct.tone + dir * 16
+      },
+      {
+        hex: "",
+        note: "same as active, alias",
+        state: "pressed",
+        tone: hct.tone + dir * 16
+      },
+      {
+        hex: "",
+        note: "+/- 4 tone, used as outline",
+        state: "focus",
+        tone: hct.tone + dir * 4
+      },
+      {
+        hex: "",
+        note: "low chroma, mid tone",
+        state: "disabled",
+        tone: dark ? 30 : 70
+      },
+      {
+        hex: "",
+        note: "alpha-blend friendly base",
+        state: "selected",
+        tone: dark ? 25 : 90
+      }
+    ];
+    for (const s of states) {
+      const chroma = s.state === "disabled" ? Math.min(hct.chroma, 6) : hct.chroma;
+      const tone = Math.max(0, Math.min(100, s.tone));
+      s.hex = hctToHex(hct.hue, chroma, tone);
+      s.tone = tone;
+    }
+    let out = `# Interaction states for ${args.base} (${dark ? "dark" : "light"} mode)
+
+`;
+    out += `| state | tone | hex | notes |
+|---|---|---|---|
+`;
+    for (const s of states)
+      out += `| ${s.state} | ${s.tone.toFixed(0)} | ${s.hex} | ${s.note} |
+`;
+    return out;
+  },
+  name: "generate_state_colors",
+  parameters: z2.object({
+    base: z2.string().describe("Base/resting color (hex, rgb, hsl)"),
+    isDark: z2.boolean().optional().default(false).describe(
+      "Whether the base color sits on a dark background. Hover lightens on dark, darkens on light."
+    )
+  })
+};
+var analyzePaletteConsistencyTool = {
+  description: "Score how visually cohesive a palette is. Reports tonal step uniformity, chroma spread, hue distribution, and a single 0-100 cohesion score, plus targeted suggestions for tightening it up.",
+  execute: async (args) => {
+    if (args.colors.length < 2) {
+      return "Need at least 2 colors to analyze cohesion.";
+    }
+    const parsed = args.colors.map((c) => ({ input: c, rgb: parseColor(c) }));
+    if (parsed.some((p) => !p.rgb)) {
+      const bad = parsed.filter((p) => !p.rgb).map((p) => p.input);
+      return `Invalid color format: ${bad.join(", ")}`;
+    }
+    const hcts = parsed.map((p) => Hct.fromInt(rgbToArgb(p.rgb)));
+    const tones = hcts.map((h) => h.tone).sort((a, b) => a - b);
+    const chromas = hcts.map((h) => h.chroma);
+    const hues = hcts.map((h) => h.hue);
+    const gaps = [];
+    for (let i = 1; i < tones.length; i++) gaps.push(tones[i] - tones[i - 1]);
+    const avgGap = gaps.reduce((a, b) => a + b, 0) / (gaps.length || 1);
+    const gapStd = Math.sqrt(
+      gaps.reduce((a, b) => a + (b - avgGap) ** 2, 0) / (gaps.length || 1)
+    );
+    const toneUniformity = Math.max(
+      0,
+      100 - gapStd / Math.max(1, avgGap) * 50
+    );
+    const avgChroma = chromas.reduce((a, b) => a + b, 0) / chromas.length;
+    const chromaStd = Math.sqrt(
+      chromas.reduce((a, b) => a + (b - avgChroma) ** 2, 0) / chromas.length
+    );
+    const chromaCohesion = Math.max(0, 100 - chromaStd * 2);
+    const targets = [0, 30, 60, 90, 120, 150, 180];
+    let harmonyHits = 0;
+    for (let i = 0; i < hues.length; i++) {
+      for (let j = i + 1; j < hues.length; j++) {
+        let d = Math.abs(hues[i] - hues[j]);
+        if (d > 180) d = 360 - d;
+        if (targets.some((t) => Math.abs(d - t) <= 15)) harmonyHits++;
+      }
+    }
+    const totalPairs = hues.length * (hues.length - 1) / 2;
+    const hueHarmony = totalPairs ? harmonyHits / totalPairs * 100 : 100;
+    const cohesion = 0.4 * toneUniformity + 0.3 * chromaCohesion + 0.3 * hueHarmony;
+    let outlier = -1;
+    let outlierGain = 0;
+    for (let i = 0; i < hcts.length; i++) {
+      const reduced = hcts.filter((_, k) => k !== i).map((h) => h.chroma);
+      const m = reduced.reduce((a, b) => a + b, 0) / reduced.length;
+      const std = Math.sqrt(
+        reduced.reduce((a, b) => a + (b - m) ** 2, 0) / reduced.length
+      );
+      const gain = chromaStd - std;
+      if (gain > outlierGain) {
+        outlierGain = gain;
+        outlier = i;
+      }
+    }
+    let out = `# Palette cohesion analysis
+
+`;
+    out += `Colors: ${args.colors.length}
+
+`;
+    out += `| metric | score | detail |
+|---|---|---|
+`;
+    out += `| Tonal step uniformity | ${toneUniformity.toFixed(0)} | gap avg ${avgGap.toFixed(1)} \xB1 ${gapStd.toFixed(1)} |
+`;
+    out += `| Chroma cohesion | ${chromaCohesion.toFixed(0)} | chroma avg ${avgChroma.toFixed(1)} \xB1 ${chromaStd.toFixed(1)} |
+`;
+    out += `| Hue harmony | ${hueHarmony.toFixed(0)} | ${harmonyHits}/${totalPairs} pairs at harmonic angles |
+`;
+    out += `| **Overall cohesion** | **${cohesion.toFixed(0)}** | weighted 0.4 / 0.3 / 0.3 |
+
+`;
+    const suggestions = [];
+    if (toneUniformity < 60)
+      suggestions.push(
+        `Tone gaps are uneven (std ${gapStd.toFixed(1)}). Snap colors to a fixed scale (e.g. tones 10/30/50/70/90).`
+      );
+    if (chromaCohesion < 60)
+      suggestions.push(
+        `Chroma varies widely (std ${chromaStd.toFixed(1)}). Mute saturated colors or boost flat ones toward chroma ${avgChroma.toFixed(0)}.`
+      );
+    if (hueHarmony < 50)
+      suggestions.push(
+        `Hues don't sit at harmonic angles (30/60/90/120/180\xB0). Try rotating outliers onto the nearest harmonic.`
+      );
+    if (outlier >= 0)
+      suggestions.push(
+        `Likely outlier: ${args.colors[outlier]} (chroma ${hcts[outlier].chroma.toFixed(0)} vs avg ${avgChroma.toFixed(0)}).`
+      );
+    if (suggestions.length === 0)
+      out += `\u2713 Palette is visually cohesive across all three axes.
+`;
+    else {
+      out += `## Suggestions
+`;
+      for (const s of suggestions) out += `- ${s}
+`;
+    }
+    return out;
+  },
+  name: "analyze_palette_consistency",
+  parameters: z2.object({
+    colors: z2.array(z2.string()).min(2).describe("Palette colors to analyze")
+  })
+};
+var SEMANTIC_OFFSETS = {
+  // Hue offsets from brand color (in HCT degrees).
+  // Secondary/tertiary use harmonic rotations; semantic statuses anchor to
+  // conventional hue ranges (red/yellow/blue) but adjust chroma/tone to feel
+  // like they belong to the same family.
+  primary: 0,
+  secondary: -30,
+  tertiary: 60
+};
+var SEMANTIC_ANCHORS = {
+  // Anchored hues for status colors. Chroma is clamped down to whatever the
+  // brand can muster so the status palette doesn't out-shout the brand.
+  error: { chromaMin: 40, hue: 25 },
+  // red
+  info: { chromaMin: 30, hue: 240 },
+  // blue
+  success: { chromaMin: 30, hue: 142 },
+  // green
+  warning: { chromaMin: 50, hue: 80 }
+  // amber
+};
+var generateSemanticPaletteTool = {
+  description: "From a single brand color, generate a complete visually-cohesive semantic palette: primary, secondary, tertiary, plus success/warning/error/info status colors. Tone and chroma are normalized in HCT space so every color feels like part of the same family.",
+  execute: async (args) => {
+    const hct = hctFromColor(args.brand);
+    if (!hct) return `Invalid color format: ${args.brand}`;
+    const dark = args.isDark ?? false;
+    const targetTone = dark ? 80 : 40;
+    const familyChroma = Math.max(24, Math.min(hct.chroma, 80));
+    const entries = [];
+    for (const [name, offset] of Object.entries(SEMANTIC_OFFSETS)) {
+      const hue = (hct.hue + offset + 360) % 360;
+      const hex = hctToHex(hue, familyChroma, targetTone);
+      entries.push({ hex, hue, name, tone: targetTone });
+    }
+    for (const [name, anchor] of Object.entries(SEMANTIC_ANCHORS)) {
+      const chroma = Math.max(anchor.chromaMin, Math.min(familyChroma, 90));
+      const hex = hctToHex(anchor.hue, chroma, targetTone);
+      entries.push({ hex, hue: anchor.hue, name, tone: targetTone });
+    }
+    const brandRgb = parseColor(args.brand);
+    let out = `# Semantic palette derived from ${args.brand}
+`;
+    out += `Mode: ${dark ? "dark" : "light"} (target tone ${targetTone})
+`;
+    out += `Family chroma: ${familyChroma.toFixed(0)} (brand was ${hct.chroma.toFixed(0)})
+
+`;
+    out += `| role | hue | hex | \u0394E2000 from brand | hsl |
+|---|---|---|---|---|
+`;
+    for (const e of entries) {
+      const rgb = parseColor(e.hex);
+      const delta = colorDistance(brandRgb, rgb, { metric: "deltaE2000" });
+      const hsl = rgbToHsl(rgb);
+      out += `| ${e.name} | ${e.hue.toFixed(0)}\xB0 | ${e.hex} | ${delta.toFixed(1)} | hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%) |
+`;
+    }
+    out += `
+## CSS
+\`\`\`css
+:root {
+`;
+    for (const e of entries) out += `  --color-${e.name}: ${e.hex};
+`;
+    out += `}
+\`\`\`
+`;
+    return out;
+  },
+  name: "generate_semantic_palette",
+  parameters: z2.object({
+    brand: z2.string().describe("Brand / seed color (hex, rgb, hsl)"),
+    isDark: z2.boolean().optional().default(false).describe("Generate the palette for a dark theme background")
+  })
+};
+
+// src/tools/color-blindness.tool.ts
+import { z as z3 } from "zod";
+
+// src/color/color-blindness.ts
+var CVD_MATRICES = {
+  deuteranomaly: [
+    0.547494,
+    0.607765,
+    -0.155259,
+    0.181692,
+    0.781742,
+    0.036566,
+    -0.01041,
+    0.027275,
+    0.983136
+  ],
+  deuteranopia: [
+    0.367322,
+    0.860646,
+    -0.227968,
+    0.280085,
+    0.672501,
+    0.047413,
+    -0.01182,
+    0.04294,
+    0.968881
+  ],
+  // Mild forms (-omaly: severity ~0.6, Machado severity 0.6 table)
+  protanomaly: [
+    0.458064,
+    0.679578,
+    -0.137642,
+    0.092785,
+    0.846313,
+    0.060902,
+    -7494e-6,
+    -0.016807,
+    1.024301
+  ],
+  // Strong forms (-opia: full dichromacy, severity 1.0)
+  protanopia: [
+    0.152286,
+    1.052583,
+    -0.204868,
+    0.114503,
+    0.786281,
+    0.099216,
+    -3882e-6,
+    -0.048116,
+    1.051998
+  ],
+  tritanomaly: [
+    1.193214,
+    -0.109812,
+    -0.083402,
+    0.058694,
+    0.901185,
+    0.040121,
+    -5978e-6,
+    0.401901,
+    0.604077
+  ],
+  tritanopia: [
+    1.255528,
+    -0.076749,
+    -0.178779,
+    -0.078411,
+    0.930809,
+    0.147602,
+    4733e-6,
+    0.691367,
+    0.3039
+  ]
+};
+function simulateCvd(rgb, type) {
+  if (type === "achromatopsia") {
+    const y = 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b;
+    const g2 = Math.max(0, Math.min(255, Math.round(y)));
+    return { b: g2, g: g2, r: g2 };
+  }
+  const m = CVD_MATRICES[type];
+  const r = srgbToLinear(rgb.r);
+  const g = srgbToLinear(rgb.g);
+  const b = srgbToLinear(rgb.b);
+  const rOut = m[0] * r + m[1] * g + m[2] * b;
+  const gOut = m[3] * r + m[4] * g + m[5] * b;
+  const bOut = m[6] * r + m[7] * g + m[8] * b;
+  return {
+    b: linearToSrgb(bOut),
+    g: linearToSrgb(gOut),
+    r: linearToSrgb(rOut)
+  };
+}
+function linearToSrgb(c) {
+  const v = c <= 31308e-7 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+  return Math.max(0, Math.min(255, Math.round(v * 255)));
+}
+function srgbToLinear(c) {
+  const n = c / 255;
+  return n <= 0.04045 ? n / 12.92 : Math.pow((n + 0.055) / 1.055, 2.4);
+}
+var CVD_PREVALENCE = {
+  achromatopsia: 3e-3,
+  deuteranomaly: 5,
+  deuteranopia: 1,
+  protanomaly: 1,
+  protanopia: 1,
+  tritanomaly: 0.01,
+  tritanopia: 3e-3
+};
+
+// src/tools/color-blindness.tool.ts
+var CVD_TYPES = [
+  "protanopia",
+  "deuteranopia",
+  "tritanopia",
+  "protanomaly",
+  "deuteranomaly",
+  "tritanomaly",
+  "achromatopsia"
+];
+var simulateColorBlindnessTool = {
+  description: "Simulate how one or more colors appear to viewers with color vision deficiency (protanopia, deuteranopia, tritanopia, their milder anomaly forms, or achromatopsia).",
+  execute: async (args) => {
+    const types = args.types && args.types.length > 0 ? args.types : CVD_TYPES;
+    const parsed = args.colors.map((c) => ({ input: c, rgb: parseColor(c) }));
+    const invalid = parsed.filter((p) => !p.rgb);
+    if (invalid.length) {
+      return `Invalid color format: ${invalid.map((p) => p.input).join(", ")}`;
+    }
+    let output = `# Color Blindness Simulation
+
+`;
+    output += `| Original | ${types.join(" | ")} |
+`;
+    output += `|${"---|".repeat(types.length + 1)}
+`;
+    for (const { input, rgb } of parsed) {
+      const simulated = types.map((t) => rgbToHex(simulateCvd(rgb, t)));
+      output += `| ${rgbToHex(rgb)} (${input}) | ${simulated.join(" | ")} |
+`;
+    }
+    output += `
+## Population prevalence
+`;
+    for (const t of types) {
+      output += `- **${t}**: ~${CVD_PREVALENCE[t]}% of population
+`;
+    }
+    return output;
+  },
+  name: "simulate_color_blindness",
+  parameters: z3.object({
+    colors: z3.array(z3.string()).min(1).describe("Colors to simulate (hex, rgb, hsl)"),
+    types: z3.array(z3.enum(CVD_TYPES)).optional().describe(
+      "Deficiency types to simulate. Defaults to all 7 (dichromacy + anomaly + achromatopsia)."
+    )
+  })
+};
+var checkPaletteAccessibilityTool = {
+  description: "Audit a color palette for color-blind accessibility. For each pair of colors, reports the perceptual distance (Delta E 2000) under each CVD type and flags pairs that become indistinguishable.",
+  execute: async (args) => {
+    const types = args.types && args.types.length > 0 ? args.types : CVD_TYPES;
+    const threshold = args.indistinguishableThreshold ?? 10;
+    const parsed = args.colors.map((c) => ({ input: c, rgb: parseColor(c) }));
+    const invalid = parsed.filter((p) => !p.rgb);
+    if (invalid.length) {
+      return `Invalid color format: ${invalid.map((p) => p.input).join(", ")}`;
+    }
+    const colors = parsed.map((p) => p.rgb);
+    const labels = parsed.map((p) => rgbToHex(p.rgb));
+    let output = `# Palette Accessibility Audit
+
+`;
+    output += `Indistinguishable threshold: \u0394E2000 < ${threshold}
+
+`;
+    const problems = [];
+    for (const type of types) {
+      const simulated = colors.map((c) => simulateCvd(c, type));
+      const collisions = [];
+      for (let i = 0; i < simulated.length; i++) {
+        for (let j = i + 1; j < simulated.length; j++) {
+          const d = colorDistance(simulated[i], simulated[j], {
+            metric: "deltaE2000"
+          });
+          if (d < threshold) {
+            collisions.push(
+              `  - ${labels[i]} \u2194 ${labels[j]}: \u0394E=${d.toFixed(1)} (sim: ${rgbToHex(
+                simulated[i]
+              )} vs ${rgbToHex(simulated[j])})`
+            );
+          }
+        }
+      }
+      output += `## ${type} (~${CVD_PREVALENCE[type]}% of population)
+`;
+      if (collisions.length === 0) {
+        output += `\u2713 All ${colors.length} colors remain distinguishable
+
+`;
+      } else {
+        output += `\u26A0 ${collisions.length} indistinguishable pair${collisions.length === 1 ? "" : "s"}:
+`;
+        output += collisions.join("\n") + "\n\n";
+        problems.push(type);
+      }
+    }
+    output += `## Summary
+`;
+    if (problems.length === 0) {
+      output += `\u2713 Palette is accessible across all tested CVD types.
+`;
+    } else {
+      output += `\u26A0 Issues detected in: ${problems.join(", ")}.
+`;
+      output += `Consider increasing tonal contrast (vary lightness) or chroma; CVD-friendly palettes rely on lightness differences rather than hue alone.
+`;
+      let worst = Infinity;
+      for (let i = 0; i < colors.length; i++) {
+        for (let j = i + 1; j < colors.length; j++) {
+          const r = getContrastRatio(colors[i], colors[j]);
+          if (r < worst) worst = r;
+        }
+      }
+      output += `Lowest WCAG luminance ratio in palette: ${worst.toFixed(2)}:1 (target \u2265 3:1 for adjacent UI swatches).
+`;
+    }
+    return output;
+  },
+  name: "check_palette_accessibility",
+  parameters: z3.object({
+    colors: z3.array(z3.string()).min(2).describe("Palette colors to audit (at least 2)"),
+    indistinguishableThreshold: z3.number().min(1).max(30).optional().default(10).describe(
+      "\u0394E2000 below which two simulated colors are considered indistinguishable (default 10)"
+    ),
+    types: z3.array(z3.enum(CVD_TYPES)).optional().describe("CVD types to audit. Defaults to all 7.")
+  })
+};
+
+// src/tools/color-conversion.tool.ts
+import { z as z4 } from "zod";
 var colorConversionTool = {
   description: "Convert colors between different formats (hex, rgb, hsl, lab, hct)",
   execute: async (args) => {
@@ -48,20 +676,20 @@ var colorConversionTool = {
         return `lab(${lab.l.toFixed(2)}, ${lab.a.toFixed(2)}, ${lab.b.toFixed(2)})`;
       }
       case "rgb":
-        return `rgb(${Math.round(rgb.r * 255)}, ${Math.round(rgb.g * 255)}, ${Math.round(rgb.b * 255)})`;
+        return `rgb(${Math.round(rgb.r)}, ${Math.round(rgb.g)}, ${Math.round(rgb.b)})`;
       default:
         return `Invalid format: ${args.to}`;
     }
   },
   name: "convert_color",
-  parameters: z.object({
-    color: z.string().describe("Color to convert (hex, rgb(), or hsl())"),
-    to: z.enum(["hex", "rgb", "hsl", "lab", "hct"]).describe("Target format")
+  parameters: z4.object({
+    color: z4.string().describe("Color to convert (hex, rgb(), or hsl())"),
+    to: z4.enum(["hex", "rgb", "hsl", "lab", "hct"]).describe("Target format")
   })
 };
 
 // src/tools/color-distance.tool.ts
-import { z as z2 } from "zod";
+import { z as z5 } from "zod";
 var colorDistanceTool = {
   description: "Calculate perceptual distance between two colors using Delta E 2000",
   execute: async (args) => {
@@ -76,84 +704,129 @@ var colorDistanceTool = {
     return `Distance between ${args.color1} and ${args.color2}: ${distance.toFixed(2)}`;
   },
   name: "color_distance",
-  parameters: z2.object({
-    color1: z2.string().describe("First color (hex, rgb, or hsl)"),
-    color2: z2.string().describe("Second color (hex, rgb, or hsl)"),
-    metric: z2.enum(["euclidean", "deltaE76", "deltaE94", "deltaE2000", "weighted"]).optional().default("deltaE2000").describe("Distance metric to use")
+  parameters: z5.object({
+    color1: z5.string().describe("First color (hex, rgb, or hsl)"),
+    color2: z5.string().describe("Second color (hex, rgb, or hsl)"),
+    metric: z5.enum(["euclidean", "deltaE76", "deltaE94", "deltaE2000", "weighted"]).optional().default("deltaE2000").describe("Distance metric to use")
   })
 };
 
-// src/tools/colors.ts
-import { formatHex, formatHsl, formatRgb, parse } from "culori";
-import { z as z3 } from "zod";
+// src/tools/contrast-checker.tool.ts
+import { z as z6 } from "zod";
 
-// src/constants.ts
-var ColorFormat = /* @__PURE__ */ ((ColorFormat2) => {
-  ColorFormat2["HEX"] = "hex";
-  ColorFormat2["HSL"] = "hsl";
-  ColorFormat2["RGB"] = "rgb";
-  return ColorFormat2;
-})(ColorFormat || {});
-
-// src/tools/colors.ts
-var convertColor = {
-  description: "Convert a color from one format to another",
-  execute: async (args) => {
-    const { color, to = "hex" /* HEX */ } = args;
-    const parsed = parse(color);
-    if (!parsed) {
-      throw new Error(`Invalid color: ${color}`);
-    }
-    switch (to) {
-      case "hex" /* HEX */:
-        return formatHex(parsed);
-      case "hsl" /* HSL */:
-        return formatHsl(parsed);
-      case "rgb" /* RGB */:
-        return formatRgb(parsed);
-      default:
-        throw new Error(`Invalid output format: ${to}`);
-    }
-  },
-  name: "convertColor",
-  parameters: z3.object({
-    color: z3.string().describe("The color to convert"),
-    to: z3.nativeEnum(ColorFormat).optional().describe("The output format")
-  })
+// src/color/apca.ts
+var SA98G = {
+  blkClmp: 1.414,
+  blkThrs: 0.022,
+  deltaYmin: 5e-4,
+  loBoTclip: -0.6,
+  loBoTexp: 0.74,
+  loClip: 0.1,
+  // Polarity exponents/factors
+  normBG: 0.56,
+  normTXT: 0.57,
+  revBG: 0.62,
+  revTXT: 0.65,
+  // Soft-clip and scale
+  scaleBoW: 1.14,
+  scaleWoB: 1.14,
+  trailingW: 0.027
 };
+var sRGBtrc = 2.4;
+var Rco = 0.2126729;
+var Gco = 0.7151522;
+var Bco = 0.072175;
+function apcaContrast(text, bg) {
+  let txtY = apcaY(text);
+  let bgY = apcaY(bg);
+  if (txtY <= SA98G.blkThrs) {
+    txtY += Math.pow(SA98G.blkThrs - txtY, SA98G.blkClmp);
+  }
+  if (bgY <= SA98G.blkThrs) {
+    bgY += Math.pow(SA98G.blkThrs - bgY, SA98G.blkClmp);
+  }
+  if (Math.abs(bgY - txtY) < SA98G.deltaYmin) return 0;
+  let outputContrast;
+  if (bgY > txtY) {
+    const SAPC = (Math.pow(bgY, SA98G.normBG) - Math.pow(txtY, SA98G.normTXT)) * SA98G.scaleBoW;
+    outputContrast = SAPC < SA98G.loClip ? 0 : SAPC - SA98G.trailingW;
+  } else {
+    const SAPC = (Math.pow(bgY, SA98G.revBG) - Math.pow(txtY, SA98G.revTXT)) * SA98G.scaleWoB;
+    outputContrast = SAPC > -SA98G.loClip ? 0 : SAPC + SA98G.trailingW;
+  }
+  return outputContrast * 100;
+}
+function apcaLevel(lc) {
+  const abs = Math.abs(lc);
+  return {
+    body: abs >= 75,
+    content: abs >= 60,
+    large: abs >= 45,
+    spot: abs >= 30
+  };
+}
+function apcaY(rgb) {
+  const r = Math.pow(rgb.r / 255, sRGBtrc);
+  const g = Math.pow(rgb.g / 255, sRGBtrc);
+  const b = Math.pow(rgb.b / 255, sRGBtrc);
+  return Rco * r + Gco * g + Bco * b;
+}
 
 // src/tools/contrast-checker.tool.ts
-import { z as z4 } from "zod";
 var contrastCheckerTool = {
-  description: "Check WCAG contrast ratio between two colors",
+  description: "Check contrast between two colors. Supports WCAG 2.x luminance ratio (default), APCA Lc (WCAG 3 draft), or both algorithms side-by-side.",
   execute: async (args) => {
     const fg = parseColor(args.foreground);
     const bg = parseColor(args.background);
     if (!fg || !bg) {
       return `Invalid color format: ${!fg ? args.foreground : args.background}`;
     }
-    const ratio = getContrastRatio(fg, bg);
-    const aa = ratio >= 4.5;
-    const aaLarge = ratio >= 3;
-    const aaa = ratio >= 7;
-    const aaaLarge = ratio >= 4.5;
-    return `Contrast Ratio: ${ratio.toFixed(2)}:1
-WCAG AA: ${aa ? "\u2713 Pass" : "\u2717 Fail"} (normal text)
-WCAG AA: ${aaLarge ? "\u2713 Pass" : "\u2717 Fail"} (large text)
-WCAG AAA: ${aaa ? "\u2713 Pass" : "\u2717 Fail"} (normal text)
-WCAG AAA: ${aaaLarge ? "\u2713 Pass" : "\u2717 Fail"} (large text)`;
+    const algorithm = args.algorithm ?? "wcag";
+    const wcagBlock = () => {
+      const ratio = getContrastRatio(fg, bg);
+      const aaLarge = ratio >= 3;
+      const aa = ratio >= 4.5;
+      const aaaLarge = ratio >= 4.5;
+      const aaa = ratio >= 7;
+      return `## WCAG 2.x luminance ratio
+Contrast Ratio: ${ratio.toFixed(2)}:1
+- AA (normal text):  ${aa ? "\u2713 Pass" : "\u2717 Fail"} (need 4.5:1)
+- AA (large text):   ${aaLarge ? "\u2713 Pass" : "\u2717 Fail"} (need 3:1)
+- AAA (normal text): ${aaa ? "\u2713 Pass" : "\u2717 Fail"} (need 7:1)
+- AAA (large text):  ${aaaLarge ? "\u2713 Pass" : "\u2717 Fail"} (need 4.5:1)`;
+    };
+    const apcaBlock = () => {
+      const lc = apcaContrast(fg, bg);
+      const level = apcaLevel(lc);
+      const polarity = lc > 0 ? "dark text on light bg" : lc < 0 ? "light text on dark bg" : "no contrast";
+      return `## APCA (WCAG 3 draft)
+Lc: ${lc.toFixed(1)} (${polarity})
+- Body text (|Lc| \u2265 75):    ${level.body ? "\u2713 Pass" : "\u2717 Fail"}
+- Content text (|Lc| \u2265 60): ${level.content ? "\u2713 Pass" : "\u2717 Fail"}
+- Large text (|Lc| \u2265 45):   ${level.large ? "\u2713 Pass" : "\u2717 Fail"}
+- Spot / non-content (|Lc| \u2265 30): ${level.spot ? "\u2713 Pass" : "\u2717 Fail"}`;
+    };
+    if (algorithm === "wcag") return wcagBlock();
+    if (algorithm === "apca") return apcaBlock();
+    return `${wcagBlock()}
+
+${apcaBlock()}`;
   },
   name: "check_contrast",
-  parameters: z4.object({
-    background: z4.string().describe("Background color"),
-    foreground: z4.string().describe("Foreground/text color")
+  parameters: z6.object({
+    algorithm: z6.enum(["wcag", "apca", "both"]).optional().default("wcag").describe(
+      "Contrast algorithm: 'wcag' (WCAG 2.x ratio), 'apca' (Lc, WCAG 3 draft), or 'both'"
+    ),
+    background: z6.string().describe("Background color"),
+    foreground: z6.string().describe("Foreground/text color")
   })
 };
 
 // src/tools/dislike-analyzer.tool.ts
+import { z as z7 } from "zod";
 var analyzeColorLikabilityTool = {
   description: "Check if a color is universally disliked (dark yellow-green associated with biological waste) and get a fixed version if needed",
-  execute: async (args, _context) => {
+  execute: async (args) => {
     const { autoFix = true, color } = args;
     try {
       const rgb = parseColor(color);
@@ -242,25 +915,15 @@ var analyzeColorLikabilityTool = {
       return `Error analyzing color: ${error instanceof Error ? error.message : String(error)}`;
     }
   },
-  inputSchema: {
-    properties: {
-      autoFix: {
-        description: "Automatically return fixed version if disliked (default: true)",
-        type: "boolean"
-      },
-      color: {
-        description: "Color to analyze (hex, rgb, hsl, etc.)",
-        type: "string"
-      }
-    },
-    required: ["color"],
-    type: "object"
-  },
-  name: "analyze_color_likability"
+  name: "analyze_color_likability",
+  parameters: z7.object({
+    autoFix: z7.boolean().optional().default(true).describe("Automatically return fixed version if disliked"),
+    color: z7.string().describe("Color to analyze (hex, rgb, hsl, etc.)")
+  })
 };
 var fixDislikedColorsBatchTool = {
   description: "Analyze and fix multiple colors, returning only liked versions",
-  execute: async (args, _context) => {
+  execute: async (args) => {
     const { colors, includeAnalysis = false } = args;
     try {
       const results = [];
@@ -330,17 +993,19 @@ var fixDislikedColorsBatchTool = {
         } else if (result.wasDisliked) {
           output += `- **${result.original}** \u2192 **${result.fixed}** (fixed)
 `;
-          if (includeAnalysis && result.hct) {
-            output += `  - Original HCT: (${result.hct.original.h.toFixed(0)}\xB0, ${result.hct.original.c.toFixed(0)}, ${result.hct.original.t.toFixed(0)})
+          if (includeAnalysis && result.hct && "original" in result.hct) {
+            const { fixed, original } = result.hct;
+            output += `  - Original HCT: (${original.h.toFixed(0)}\xB0, ${original.c.toFixed(0)}, ${original.t.toFixed(0)})
 `;
-            output += `  - Fixed HCT: (${result.hct.fixed.h.toFixed(0)}\xB0, ${result.hct.fixed.c.toFixed(0)}, ${result.hct.fixed.t.toFixed(0)})
+            output += `  - Fixed HCT: (${fixed.h.toFixed(0)}\xB0, ${fixed.c.toFixed(0)}, ${fixed.t.toFixed(0)})
 `;
           }
         } else {
           output += `- **${result.original}** \u2713 (already liked)
 `;
-          if (includeAnalysis && result.hct) {
-            output += `  - HCT: (${result.hct.h.toFixed(0)}\xB0, ${result.hct.c.toFixed(0)}, ${result.hct.t.toFixed(0)})
+          if (includeAnalysis && result.hct && "h" in result.hct) {
+            const { c, h, t } = result.hct;
+            output += `  - HCT: (${h.toFixed(0)}\xB0, ${c.toFixed(0)}, ${t.toFixed(0)})
 `;
           }
         }
@@ -358,28 +1023,15 @@ var fixDislikedColorsBatchTool = {
       return `Error processing colors: ${error instanceof Error ? error.message : String(error)}`;
     }
   },
-  inputSchema: {
-    properties: {
-      colors: {
-        description: "Array of colors to analyze (hex, rgb, hsl, etc.)",
-        items: {
-          type: "string"
-        },
-        type: "array"
-      },
-      includeAnalysis: {
-        description: "Include detailed analysis for each color (default: false)",
-        type: "boolean"
-      }
-    },
-    required: ["colors"],
-    type: "object"
-  },
-  name: "fix_disliked_colors_batch"
+  name: "fix_disliked_colors_batch",
+  parameters: z7.object({
+    colors: z7.array(z7.string()).min(1).describe("Array of colors to analyze (hex, rgb, hsl, etc.)"),
+    includeAnalysis: z7.boolean().optional().default(false).describe("Include detailed analysis for each color")
+  })
 };
 
 // src/tools/gradient-generator.tool.ts
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 var gradientGeneratorTool = {
   description: "Generate a smooth gradient between colors with multiple interpolation methods",
   execute: async (args) => {
@@ -538,17 +1190,20 @@ Input colors: ${colors.join(" \u2192 ")}`;
     }
   },
   name: "generate_gradient",
-  parameters: z5.object({
-    colors: z5.array(z5.string()).min(2).describe("Colors to create gradient between (minimum 2)"),
-    easing: z5.enum(["linear", "ease-in", "ease-out", "ease-in-out"]).default("linear").describe("Easing function for gradient transition"),
-    format: z5.enum(["hex", "css-linear", "css-radial", "array"]).default("array").describe("Output format for the gradient"),
-    interpolation: z5.enum(["rgb", "hsl", "lab", "lch", "hct"]).default("lab").describe(
+  parameters: z8.object({
+    colors: z8.array(z8.string()).min(2).describe("Colors to create gradient between (minimum 2)"),
+    easing: z8.enum(["linear", "ease-in", "ease-out", "ease-in-out"]).default("linear").describe("Easing function for gradient transition"),
+    format: z8.enum(["hex", "css-linear", "css-radial", "array"]).default("array").describe("Output format for the gradient"),
+    interpolation: z8.enum(["rgb", "hsl", "lab", "lch", "hct"]).default("lab").describe(
       "Color space for interpolation (lab/lch/hct are perceptually smooth)"
     ),
-    steps: z5.number().min(3).max(100).describe("Number of colors in the gradient")
+    steps: z8.number().min(3).max(100).describe("Number of colors in the gradient")
   })
 };
 
+// src/tools/image-extraction.tools.ts
+import { z as z9 } from "zod";
+
 // src/color/utils/math_utils.ts
 function clampInt(min, max, input) {
   if (input < min) {
@@ -594,17 +1249,17 @@ function argbFromLab(l, a, b) {
   const zNormalized = labInvf(fz);
   const x = xNormalized * whitePoint[0];
   const y = yNormalized * whitePoint[1];
-  const z10 = zNormalized * whitePoint[2];
-  return argbFromXyz(x, y, z10);
+  const z15 = zNormalized * whitePoint[2];
+  return argbFromXyz(x, y, z15);
 }
 function argbFromRgb(red, green, blue) {
   return (255 << 24 | (red & 255) << 16 | (green & 255) << 8 | blue & 255) >>> 0;
 }
-function argbFromXyz(x, y, z10) {
+function argbFromXyz(x, y, z15) {
   const matrix = XYZ_TO_SRGB;
-  const linearR = matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z10;
-  const linearG = matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z10;
-  const linearB = matrix[2][0] * x + matrix[2][1] * y + matrix[2][2] * z10;
+  const linearR = matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z15;
+  const linearG = matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z15;
+  const linearB = matrix[2][0] * x + matrix[2][1] * y + matrix[2][2] * z15;
   const r = delinearized(linearR);
   const g = delinearized(linearG);
   const b = delinearized(linearB);
@@ -633,11 +1288,11 @@ function labFromArgb(argb) {
   const matrix = SRGB_TO_XYZ;
   const x = matrix[0][0] * linearR + matrix[0][1] * linearG + matrix[0][2] * linearB;
   const y = matrix[1][0] * linearR + matrix[1][1] * linearG + matrix[1][2] * linearB;
-  const z10 = matrix[2][0] * linearR + matrix[2][1] * linearG + matrix[2][2] * linearB;
+  const z15 = matrix[2][0] * linearR + matrix[2][1] * linearG + matrix[2][2] * linearB;
   const whitePoint = WHITE_POINT_D65;
   const xNormalized = x / whitePoint[0];
   const yNormalized = y / whitePoint[1];
-  const zNormalized = z10 / whitePoint[2];
+  const zNormalized = z15 / whitePoint[2];
   const fx = labF(xNormalized);
   const fy = labF(yNormalized);
   const fz = labF(zNormalized);
@@ -954,6 +1609,13 @@ var Box = class {
     this.b1 = b1;
     this.vol = vol;
   }
+  r0;
+  r1;
+  g0;
+  g1;
+  b0;
+  b1;
+  vol;
 };
 var CreateBoxesResult = class {
   /**
@@ -966,12 +1628,16 @@ var CreateBoxesResult = class {
     this.requestedCount = requestedCount;
     this.resultCount = resultCount;
   }
+  requestedCount;
+  resultCount;
 };
 var MaximizeResult = class {
   constructor(cutLocation, maximum) {
     this.cutLocation = cutLocation;
     this.maximum = maximum;
   }
+  cutLocation;
+  maximum;
 };
 var QuantizerWu = class {
   constructor(weights = [], momentsR = [], momentsG = [], momentsB = [], moments = [], cubes = []) {
@@ -982,6 +1648,12 @@ var QuantizerWu = class {
     this.moments = moments;
     this.cubes = cubes;
   }
+  weights;
+  momentsR;
+  momentsG;
+  momentsB;
+  moments;
+  cubes;
   /**
    * @param pixels Colors in ARGB format.
    * @param maxColors The number of colors to divide the image into. A lower
@@ -1581,9 +2253,14 @@ function generateMaterialTheme(sourceColor, options = {}) {
 }
 
 // src/tools/image-extraction.tools.ts
+var imageDataSchema = z9.object({
+  data: z9.array(z9.number()).describe("Flat array of RGBA values (0-255)"),
+  height: z9.number().int().positive().describe("Image height in pixels"),
+  width: z9.number().int().positive().describe("Image width in pixels")
+}).describe("Image data with RGBA values");
 var extractImageColorsTool = {
   description: "Extract dominant colors from an image. Input should be image data as an array of RGBA values.",
-  execute: async (args, _context) => {
+  execute: async (args) => {
     const {
       format = "json",
       imageData,
@@ -1591,7 +2268,7 @@ var extractImageColorsTool = {
       quality = "medium"
     } = args;
     try {
-      const data = imageData.data instanceof Uint8ClampedArray ? imageData.data : new Uint8ClampedArray(imageData.data);
+      const data = new Uint8ClampedArray(imageData.data);
       const processedImageData = {
         data,
         height: imageData.height,
@@ -1616,60 +2293,20 @@ var extractImageColorsTool = {
       return `Error extracting colors: ${error instanceof Error ? error.message : String(error)}`;
     }
   },
-  inputSchema: {
-    properties: {
-      format: {
-        description: "Output format: json, css, or palette (default: json)",
-        enum: ["json", "css", "palette"],
-        type: "string"
-      },
-      imageData: {
-        description: "Image data with RGBA values",
-        properties: {
-          data: {
-            description: "Flat array of RGBA values (0-255)",
-            items: { type: "number" },
-            type: "array"
-          },
-          height: {
-            description: "Image height in pixels",
-            type: "number"
-          },
-          width: {
-            description: "Image width in pixels",
-            type: "number"
-          }
-        },
-        required: ["data", "width", "height"],
-        type: "object"
-      },
-      maxColors: {
-        description: "Maximum number of colors to extract (default: 5)",
-        maximum: 20,
-        minimum: 1,
-        type: "number"
-      },
-      quality: {
-        description: "Extraction quality: low, medium, or high (default: medium)",
-        enum: ["low", "medium", "high"],
-        type: "string"
-      }
-    },
-    required: ["imageData"],
-    type: "object"
-  },
-  name: "extract_image_colors"
+  name: "extract_image_colors",
+  parameters: z9.object({
+    format: z9.enum(["json", "css", "palette"]).optional().default("json").describe("Output format"),
+    imageData: imageDataSchema,
+    maxColors: z9.number().int().min(1).max(20).optional().default(5).describe("Maximum number of colors to extract"),
+    quality: z9.enum(["low", "medium", "high"]).optional().default("medium").describe("Extraction quality")
+  })
 };
 var generateThemeFromImageTool = {
   description: "Generate a complete Material Design 3 theme from an image",
-  execute: async (args, _context) => {
-    const {
-      imageData,
-      includeCustomColors = true,
-      isDark = false
-    } = args;
+  execute: async (args) => {
+    const { imageData, includeCustomColors = true, isDark = false } = args;
     try {
-      const data = imageData.data instanceof Uint8ClampedArray ? imageData.data : new Uint8ClampedArray(imageData.data);
+      const data = new Uint8ClampedArray(imageData.data);
       const processedImageData = {
         data,
         height: imageData.height,
@@ -1746,41 +2383,12 @@ var generateThemeFromImageTool = {
       return `Error generating theme: ${error instanceof Error ? error.message : String(error)}`;
     }
   },
-  inputSchema: {
-    properties: {
-      imageData: {
-        description: "Image data with RGBA values",
-        properties: {
-          data: {
-            description: "Flat array of RGBA values (0-255)",
-            items: { type: "number" },
-            type: "array"
-          },
-          height: {
-            description: "Image height in pixels",
-            type: "number"
-          },
-          width: {
-            description: "Image width in pixels",
-            type: "number"
-          }
-        },
-        required: ["data", "width", "height"],
-        type: "object"
-      },
-      includeCustomColors: {
-        description: "Include custom colors from image (default: true)",
-        type: "boolean"
-      },
-      isDark: {
-        description: "Generate dark theme (default: false for light theme)",
-        type: "boolean"
-      }
-    },
-    required: ["imageData"],
-    type: "object"
-  },
-  name: "generate_theme_from_image"
+  name: "generate_theme_from_image",
+  parameters: z9.object({
+    imageData: imageDataSchema,
+    includeCustomColors: z9.boolean().optional().default(true).describe("Include custom colors from image"),
+    isDark: z9.boolean().optional().default(false).describe("Generate dark theme (false for light theme)")
+  })
 };
 function formatAsCSS(colors) {
   let css = ":root {\n";
@@ -1827,7 +2435,7 @@ function formatAsPalette(colors) {
 }
 
 // src/tools/material-theme.tools.ts
-import { z as z6 } from "zod";
+import { z as z10 } from "zod";
 var generateMaterialThemeTool = {
   description: "Generate a complete Material Design 3 color theme from a source color",
   execute: async (args) => {
@@ -1905,9 +2513,9 @@ Tertiary: ${[40, 80].map((t) => rgbToHex(corePalette.tertiary.tone(t))).join(",
     return result;
   },
   name: "generate_material_theme",
-  parameters: z6.object({
-    includeCustomColors: z6.boolean().optional().default(false).describe("Include custom color palettes"),
-    sourceColor: z6.string().describe("Source color for theme generation")
+  parameters: z10.object({
+    includeCustomColors: z10.boolean().optional().default(false).describe("Include custom color palettes"),
+    sourceColor: z10.string().describe("Source color for theme generation")
   })
 };
 var harmonizeColorsTool = {
@@ -1951,10 +2559,10 @@ Original: ${args.colors.join(", ")}
 Result: ${results.join(", ")}`;
   },
   name: "harmonize_colors",
-  parameters: z6.object({
-    colors: z6.array(z6.string()).min(2).max(10).describe("Array of colors to harmonize"),
-    factor: z6.number().min(0).max(1).optional().default(0.5).describe("Harmonization strength (0-1)"),
-    method: z6.enum(["blend", "harmonize", "temperature"]).optional().default("harmonize").describe("Harmonization method")
+  parameters: z10.object({
+    colors: z10.array(z10.string()).min(2).max(10).describe("Array of colors to harmonize"),
+    factor: z10.number().min(0).max(1).optional().default(0.5).describe("Harmonization strength (0-1)"),
+    method: z10.enum(["blend", "harmonize", "temperature"]).optional().default("harmonize").describe("Harmonization method")
   })
 };
 var generateTonalPaletteTool = {
@@ -1991,14 +2599,137 @@ HCT: h=${hct.h.toFixed(1)}\xB0, c=${hct.c.toFixed(1)}, t=${hct.t.toFixed(1)}
 ${colors.map(({ hex, tone }) => `Tone ${tone}: ${hex}`).join("\n")}`;
   },
   name: "generate_tonal_palette",
-  parameters: z6.object({
-    color: z6.string().describe("Base color for palette"),
-    tones: z6.array(z6.number()).optional().describe("Custom tone values (default: Material standard tones)")
+  parameters: z10.object({
+    color: z10.string().describe("Base color for palette"),
+    tones: z10.array(z10.number()).optional().describe("Custom tone values (default: Material standard tones)")
+  })
+};
+
+// src/tools/palette-export.tool.ts
+import { z as z11 } from "zod";
+var FORMATS = ["css", "scss", "tailwind", "tokens", "json"];
+function asCss(items) {
+  const body = items.map(({ hex, name }) => `  --${name}: ${hex};`).join("\n");
+  return `:root {
+${body}
+}
+`;
+}
+function asJson(items) {
+  const obj = {};
+  for (const { hex, name } of items) {
+    const rgb = parseColor(hex);
+    const hsl = rgbToHsl(rgb);
+    obj[name] = {
+      hex,
+      hsl: `hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%)`,
+      rgb: `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`
+    };
+  }
+  return JSON.stringify(obj, null, 2) + "\n";
+}
+function asScss(items) {
+  return items.map(({ hex, name }) => `$${name}: ${hex};`).join("\n") + "\n";
+}
+function asTailwind(items, prefix) {
+  const key = prefix ?? "palette";
+  const lines = items.map(({ hex, name }) => {
+    const entry = prefix && name.startsWith(`${prefix}-`) ? name.slice(prefix.length + 1) : name;
+    return `      "${entry}": "${hex}",`;
+  }).join("\n");
+  return `// tailwind.config.js
+module.exports = {
+  theme: {
+    extend: {
+      colors: {
+        "${key}": {
+${lines}
+        },
+      },
+    },
+  },
+};
+`;
+}
+function asTokens(items, prefix) {
+  const group = prefix ?? "color";
+  const obj = {
+    [group]: Object.fromEntries(
+      items.map(({ hex, name }) => {
+        const entry = prefix && name.startsWith(`${prefix}-`) ? name.slice(prefix.length + 1) : name;
+        return [entry, { $type: "color", $value: hex }];
+      })
+    )
+  };
+  return JSON.stringify(obj, null, 2) + "\n";
+}
+function defaultName(index) {
+  const scale = [
+    "50",
+    "100",
+    "200",
+    "300",
+    "400",
+    "500",
+    "600",
+    "700",
+    "800",
+    "900"
+  ];
+  return scale[index] ?? String((index + 1) * 100);
+}
+function resolveNames(colors, names, prefix) {
+  return colors.map((c, i) => {
+    const parsed = parseColor(c);
+    if (!parsed) throw new Error(`Invalid color: ${c}`);
+    const hex = rgbToHex(parsed);
+    const raw = names?.[i] ?? defaultName(i);
+    const slug = raw.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+    const name = prefix ? `${prefix}-${slug}` : slug;
+    return { hex, name };
+  });
+}
+var exportPaletteTool = {
+  description: "Export a list of colors as CSS custom properties, SCSS variables, a Tailwind config snippet, W3C design tokens, or JSON.",
+  execute: async (args) => {
+    const { colors, format, names, prefix } = args;
+    if (names && names.length !== colors.length) {
+      return `Error: names array length (${names.length}) must match colors length (${colors.length}).`;
+    }
+    let items;
+    try {
+      items = resolveNames(colors, names, prefix);
+    } catch (e) {
+      return e instanceof Error ? e.message : String(e);
+    }
+    switch (format) {
+      case "css":
+        return asCss(items);
+      case "json":
+        return asJson(items);
+      case "scss":
+        return asScss(items);
+      case "tailwind":
+        return asTailwind(items, prefix);
+      case "tokens":
+        return asTokens(items, prefix);
+    }
+  },
+  name: "export_palette",
+  parameters: z11.object({
+    colors: z11.array(z11.string()).min(1).describe("Palette colors"),
+    format: z11.enum(FORMATS).describe(
+      "Output format: css (custom properties), scss (variables), tailwind (config), tokens (W3C design tokens), json"
+    ),
+    names: z11.array(z11.string()).optional().describe(
+      "Optional names for each color. Length must match colors. Defaults to a 50/100\u2026900 scale."
+    ),
+    prefix: z11.string().optional().describe("Optional prefix for variable/token names (e.g. 'brand')")
   })
 };
 
 // src/tools/palette-generator.tool.ts
-import { z as z7 } from "zod";
+import { z as z12 } from "zod";
 var paletteGeneratorTool = {
   description: "Generate a color palette from a base color",
   execute: async (args) => {
@@ -2084,10 +2815,10 @@ var paletteGeneratorTool = {
 ${palette.map((color, i) => `${i + 1}. ${color}`).join("\n")}`;
   },
   name: "generate_palette",
-  parameters: z7.object({
-    baseColor: z7.string().describe("Base color for palette generation"),
-    count: z7.number().min(3).max(10).default(5).describe("Number of colors to generate"),
-    type: z7.enum([
+  parameters: z12.object({
+    baseColor: z12.string().describe("Base color for palette generation"),
+    count: z12.number().min(3).max(10).default(5).describe("Number of colors to generate"),
+    type: z12.enum([
       "monochromatic",
       "analogous",
       "complementary",
@@ -2098,7 +2829,7 @@ ${palette.map((color, i) => `${i + 1}. ${color}`).join("\n")}`;
 };
 
 // src/tools/palette-with-locks.tool.ts
-import { z as z8 } from "zod";
+import { z as z13 } from "zod";
 var paletteWithLocksTool = {
   description: "Generate a color palette while preserving specific locked colors",
   execute: async (args) => {
@@ -2135,7 +2866,9 @@ var paletteWithLocksTool = {
             };
             let minDistance = Infinity;
             for (const locked of parsedLocked) {
-              const dist = colorDistance(candidate, locked, "deltaE2000");
+              const dist = colorDistance(candidate, locked, {
+                metric: "deltaE2000"
+              });
               if (dist < minDistance) minDistance = dist;
             }
             if (minDistance > maxMinDistance) {
@@ -2188,14 +2921,12 @@ var paletteWithLocksTool = {
       }
       case "harmony": {
         const baseHsl = rgbToHsl(parsedLocked[0]);
-        const hueStep = 360 / totalColors;
         for (let i = 0; i < remainingSlots; i++) {
-          let newHue = baseHsl.h;
           let attempts = 0;
           let bestColor = null;
           let maxMinDistance = 0;
           while (attempts < 36) {
-            newHue = (baseHsl.h + attempts * 10) % 360;
+            const newHue = (baseHsl.h + attempts * 10) % 360;
             const candidate = hslToRgb({
               h: newHue,
               l: baseHsl.l + (Math.random() - 0.5) * 20,
@@ -2203,7 +2934,9 @@ var paletteWithLocksTool = {
             });
             let minDistance = Infinity;
             for (const locked of parsedLocked) {
-              const dist = colorDistance(candidate, locked, "deltaE2000");
+              const dist = colorDistance(candidate, locked, {
+                metric: "deltaE2000"
+              });
               if (dist < minDistance) minDistance = dist;
             }
             if (minDistance > maxMinDistance && minDistance > 10) {
@@ -2237,18 +2970,18 @@ Color space: ${colorSpace}
 Total colors: ${totalColors}`;
   },
   name: "generate_palette_with_locks",
-  parameters: z8.object({
-    colorSpace: z8.enum(["hsl", "lab"]).default("hsl").describe("Color space for interpolation (affects gradient smoothness)"),
-    lockedColors: z8.array(z8.string()).min(1).describe("Colors that must be included in the palette"),
-    mode: z8.enum(["harmony", "contrast", "gradient"]).default("harmony").describe(
+  parameters: z13.object({
+    colorSpace: z13.enum(["hsl", "lab"]).default("hsl").describe("Color space for interpolation (affects gradient smoothness)"),
+    lockedColors: z13.array(z13.string()).min(1).describe("Colors that must be included in the palette"),
+    mode: z13.enum(["harmony", "contrast", "gradient"]).default("harmony").describe(
       "Generation mode: harmony (similar), contrast (different), or gradient (smooth transition)"
     ),
-    totalColors: z8.number().min(2).max(20).describe("Total number of colors in the final palette")
+    totalColors: z13.number().min(2).max(20).describe("Total number of colors in the final palette")
   })
 };
 
 // src/tools/theme-matching.tools.ts
-import { z as z9 } from "zod";
+import { z as z14 } from "zod";
 
 // src/theme/matcher.ts
 var DEFAULT_WEIGHTS = {
@@ -2398,7 +3131,7 @@ function calculateHctDistance(color1, color2) {
     Math.pow(hueDiff * hueWeight, 2) + Math.pow(chromaDiff * chromaWeight, 2) + Math.pow(toneDiff * toneWeight, 2)
   ) * 100;
 }
-function calculateMatchScore(inputHct, candidate, distance, weights, options) {
+function calculateMatchScore(_inputHct, candidate, distance, weights, options) {
   const perceptualScore = Math.max(0, 100 - distance) / 100;
   let semanticScore = 0.5;
   if (options.preferredRole && candidate.role) {
@@ -2831,7 +3564,7 @@ function refactorCss(css, themeVariables, options = {}) {
   } = options;
   const replacements = [];
   const warnings = [];
-  let refactoredCss = css;
+  let refactoredCss;
   let totalColors = 0;
   let replacedColors = 0;
   let totalConfidence = 0;
@@ -3025,11 +3758,11 @@ Alternatives:`;
     return result;
   },
   name: "match_theme_color",
-  parameters: z9.object({
-    color: z9.string().describe("Color to match (hex, rgb, hsl)"),
-    context: z9.enum(["text", "background", "border", "shadow", "accent", "decorative"]).optional().describe("Usage context for better matching"),
-    minConfidence: z9.number().min(0).max(100).optional().default(70).describe("Minimum confidence threshold (0-100)"),
-    themeCSS: z9.string().describe("CSS containing theme variables")
+  parameters: z14.object({
+    color: z14.string().describe("Color to match (hex, rgb, hsl)"),
+    context: z14.enum(["text", "background", "border", "shadow", "accent", "decorative"]).optional().describe("Usage context for better matching"),
+    minConfidence: z14.number().min(0).max(100).optional().default(70).describe("Minimum confidence threshold (0-100)"),
+    themeCSS: z14.string().describe("CSS containing theme variables")
   })
 };
 var refactorCssWithThemeTool = {
@@ -3078,12 +3811,12 @@ ${generateRefactoringReport(result)}`;
     return output;
   },
   name: "refactor_css_with_theme",
-  parameters: z9.object({
-    css: z9.string().describe("CSS content to refactor"),
-    generateReport: z9.boolean().optional().default(false).describe("Generate detailed refactoring report"),
-    minConfidence: z9.number().min(0).max(100).optional().default(70).describe("Minimum confidence for replacements"),
-    preserveOriginal: z9.boolean().optional().default(true).describe("Keep original values as comments"),
-    themeCSS: z9.string().describe("CSS containing theme variables")
+  parameters: z14.object({
+    css: z14.string().describe("CSS content to refactor"),
+    generateReport: z14.boolean().optional().default(false).describe("Generate detailed refactoring report"),
+    minConfidence: z14.number().min(0).max(100).optional().default(70).describe("Minimum confidence for replacements"),
+    preserveOriginal: z14.boolean().optional().default(true).describe("Keep original values as comments"),
+    themeCSS: z14.string().describe("CSS containing theme variables")
   })
 };
 var matchThemeColorsBatchTool = {
@@ -3116,10 +3849,10 @@ Summary:
     return result;
   },
   name: "match_theme_colors_batch",
-  parameters: z9.object({
-    colors: z9.array(z9.string()).min(1).max(50).describe("Array of colors to match"),
-    context: z9.enum(["text", "background", "border", "shadow", "accent", "decorative"]).optional().describe("Usage context for all colors"),
-    themeCSS: z9.string().describe("CSS containing theme variables")
+  parameters: z14.object({
+    colors: z14.array(z14.string()).min(1).max(50).describe("Array of colors to match"),
+    context: z14.enum(["text", "background", "border", "shadow", "accent", "decorative"]).optional().describe("Usage context for all colors"),
+    themeCSS: z14.string().describe("CSS containing theme variables")
   })
 };
 var generateThemeCssTool = {
@@ -3235,14 +3968,14 @@ var generateThemeCssTool = {
     return css;
   },
   name: "generate_theme_css",
-  parameters: z9.object({
-    includeTones: z9.array(z9.number()).optional().describe(
+  parameters: z14.object({
+    includeTones: z14.array(z14.number()).optional().describe(
       "Tone values to include (default: 0,10,20,30,40,50,60,70,80,90,95,99,100)"
     ),
-    prefix: z9.string().optional().default("color").describe(
+    prefix: z14.string().optional().default("color").describe(
       "Prefix for CSS variables (e.g., 'color' \u2192 --color-primary-50)"
     ),
-    sourceColor: z9.string().describe("Source color for theme generation")
+    sourceColor: z14.string().describe("Source color for theme generation")
   })
 };
 
@@ -3250,14 +3983,22 @@ var generateThemeCssTool = {
 var server = new CoolorsMcp({
   instructions: "Advanced color operations server with Material Design 3 support, CSS theme matching, image extraction, and accessibility compliance. Uses HCT color space for perceptually accurate operations.",
   name: "coolors-mcp",
-  version: "1.0.0"
+  version: "1.1.0"
 });
 server.addTool(colorConversionTool);
 server.addTool(colorDistanceTool);
 server.addTool(contrastCheckerTool);
+server.addTool(adjustColorTool);
 server.addTool(paletteGeneratorTool);
 server.addTool(paletteWithLocksTool);
 server.addTool(gradientGeneratorTool);
+server.addTool(exportPaletteTool);
+server.addTool(simulateColorBlindnessTool);
+server.addTool(checkPaletteAccessibilityTool);
+server.addTool(generateTonalScaleTool);
+server.addTool(generateStateColorsTool);
+server.addTool(analyzePaletteConsistencyTool);
+server.addTool(generateSemanticPaletteTool);
 server.addTool(generateMaterialThemeTool);
 server.addTool(harmonizeColorsTool);
 server.addTool(generateTonalPaletteTool);