@pixerate/editor 0.145.0 → 0.147.0

package/dist/gradient/index.cjs

@@ -0,0 +1,1549 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkFJ2MSI43cjs = require('../chunk-FJ2MSI43.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkUKCJ43YLcjs = require('../chunk-UKCJ43YL.cjs');
+require('../chunk-IPJ3TEYR.cjs');
+
+// src/gradient/model.ts
+function clamp(v, min, max) {
+  return Math.max(min, Math.min(max, v));
+}
+function gradientMidpointRemap(u, m) {
+  const mid = clamp(m, 0.05, 0.95);
+  if (Math.abs(mid - 0.5) < 1e-6) return u;
+  return u <= mid ? 0.5 * u / mid : 0.5 + 0.5 * (u - mid) / (1 - mid);
+}
+function normalizeGradient(input) {
+  if (typeof input === "string") {
+    const parsed = parseCssGradient(input);
+    if (!parsed) {
+      return { error: `Could not parse CSS gradient: "${input}".` };
+    }
+    return { gradient: parsed };
+  }
+  if (!input || typeof input !== "object") {
+    return { error: "Gradient must be an object." };
+  }
+  const obj = input;
+  const type = obj.type === "radial" || obj.type === "conic" ? obj.type : "linear";
+  if (!Array.isArray(obj.stops)) {
+    return { error: "Gradient stops must be an array." };
+  }
+  if (obj.stops.length < 2) {
+    return { error: `A gradient needs at least 2 stops; it has ${obj.stops.length}.` };
+  }
+  const usedIds = /* @__PURE__ */ new Set();
+  for (const s of obj.stops) {
+    if (s && typeof s === "object" && typeof s.id === "string" && s.id.trim()) {
+      usedIds.add(s.id.trim());
+    }
+  }
+  let nextIdIndex = 1;
+  const getNextId = () => {
+    while (usedIds.has(`s${nextIdIndex}`)) {
+      nextIdIndex++;
+    }
+    const id = `s${nextIdIndex}`;
+    usedIds.add(id);
+    nextIdIndex++;
+    return id;
+  };
+  const stops = [];
+  for (let i = 0; i < obj.stops.length; i++) {
+    const s = obj.stops[i];
+    if (!s || typeof s !== "object") {
+      return { error: `Stop at index ${i} must be an object.` };
+    }
+    const rawStop = s;
+    let normColor = null;
+    if (typeof rawStop.color === "string" || rawStop.color && typeof rawStop.color === "object") {
+      const dual = _chunkUKCJ43YLcjs.normalizeDualColor.call(void 0, rawStop.color);
+      if (dual) {
+        normColor = _chunkUKCJ43YLcjs.formatDualColor.call(void 0, dual);
+      }
+    }
+    if (!normColor) {
+      return { error: `Stop at index ${i} has an invalid colour.` };
+    }
+    let offset = Number(rawStop.offset);
+    if (!Number.isFinite(offset)) {
+      offset = obj.stops.length === 1 ? 0 : i / (obj.stops.length - 1);
+    }
+    offset = clamp(offset, 0, 1);
+    const id = typeof rawStop.id === "string" && rawStop.id.trim() ? rawStop.id.trim() : getNextId();
+    const stop = {
+      id,
+      offset,
+      color: normColor
+    };
+    if (rawStop.midpoint !== void 0 && rawStop.midpoint !== null) {
+      const m = Number(rawStop.midpoint);
+      if (Number.isFinite(m)) {
+        stop.midpoint = clamp(m, 0.05, 0.95);
+      }
+    }
+    stops.push(stop);
+  }
+  stops.sort((a, b) => a.offset - b.offset);
+  const gradient = {
+    type,
+    stops
+  };
+  if (type === "linear" || type === "conic") {
+    if (obj.angle !== void 0 && Number.isFinite(Number(obj.angle))) {
+      gradient.angle = (Number(obj.angle) % 360 + 360) % 360;
+    } else {
+      gradient.angle = type === "linear" ? 180 : 0;
+    }
+  }
+  if (type === "radial" || type === "conic") {
+    if (obj.center && typeof obj.center === "object") {
+      const cx = Number(obj.center.x);
+      const cy = Number(obj.center.y);
+      gradient.center = {
+        x: Number.isFinite(cx) ? clamp(cx, 0, 1) : 0.5,
+        y: Number.isFinite(cy) ? clamp(cy, 0, 1) : 0.5
+      };
+    } else {
+      gradient.center = { x: 0.5, y: 0.5 };
+    }
+  }
+  if (type === "radial") {
+    gradient.shape = obj.shape === "circle" ? "circle" : "ellipse";
+  }
+  const allowedInterp = ["srgb", "srgb-linear", "oklab", "oklch"];
+  if (obj.interpolation && allowedInterp.includes(obj.interpolation)) {
+    gradient.interpolation = obj.interpolation;
+  } else {
+    gradient.interpolation = "oklab";
+  }
+  if (obj.repeating) {
+    gradient.repeating = true;
+  }
+  return { gradient };
+}
+function createGradient(colorsOrOptions, options) {
+  if (Array.isArray(colorsOrOptions)) {
+    const colors = colorsOrOptions;
+    const resolvedColors = colors.length >= 2 ? colors : colors.length === 1 ? [colors[0], colors[0]] : ["#000000", "#ffffff"];
+    const stops = resolvedColors.map((color, i) => ({
+      id: `s${i + 1}`,
+      offset: i / (resolvedColors.length - 1),
+      color: _chunkUKCJ43YLcjs.formatDualColor.call(void 0, _nullishCoalesce(_chunkUKCJ43YLcjs.normalizeDualColor.call(void 0, color), () => ( { light: "#000000", dark: "#000000" })))
+    }));
+    const res2 = normalizeGradient({
+      ...options,
+      stops
+    });
+    if ("error" in res2) {
+      throw new Error(res2.error);
+    }
+    return res2.gradient;
+  }
+  if (colorsOrOptions && typeof colorsOrOptions === "object" && !Array.isArray(colorsOrOptions)) {
+    const raw = colorsOrOptions;
+    let stops = raw.stops;
+    if (!stops || stops.length === 0) {
+      stops = [
+        { id: "s1", offset: 0, color: "#000000" },
+        { id: "s2", offset: 1, color: "#ffffff" }
+      ];
+    } else if (typeof stops[0] === "string") {
+      const strStops = stops;
+      stops = strStops.map((color, i) => ({
+        id: `s${i + 1}`,
+        offset: i / (strStops.length - 1),
+        color
+      }));
+    }
+    const res2 = normalizeGradient({
+      ...raw,
+      stops
+    });
+    if ("error" in res2) {
+      throw new Error(res2.error);
+    }
+    return res2.gradient;
+  }
+  const res = normalizeGradient({
+    ...options,
+    stops: [
+      { id: "s1", offset: 0, color: "#000000" },
+      { id: "s2", offset: 1, color: "#ffffff" }
+    ]
+  });
+  if ("error" in res) {
+    throw new Error(res.error);
+  }
+  return res.gradient;
+}
+function isDualColorValue(val) {
+  if (typeof val === "string") {
+    return val.trim().toLowerCase().startsWith("light-dark(");
+  }
+  if (_chunkUKCJ43YLcjs.isDualColor.call(void 0, val)) {
+    return val.light !== val.dark;
+  }
+  return false;
+}
+function isDualGradient(g) {
+  return g.stops.some((s) => isDualColorValue(s.color));
+}
+function resolveGradient(g, scheme) {
+  return {
+    ...g,
+    center: g.center ? { ...g.center } : void 0,
+    stops: g.stops.map((s) => ({
+      ...s,
+      color: _nullishCoalesce(_chunkUKCJ43YLcjs.resolveColor.call(void 0, s.color, scheme), () => ( s.color))
+    }))
+  };
+}
+function sampleGradient(g, t, scheme = "light") {
+  const resolved = resolveGradient(g, scheme);
+  const clampedT = clamp(t, 0, 1);
+  const stops = resolved.stops;
+  if (clampedT <= stops[0].offset) {
+    return stops[0].color;
+  }
+  if (clampedT >= stops[stops.length - 1].offset) {
+    return stops[stops.length - 1].color;
+  }
+  let i = 0;
+  while (i < stops.length - 1 && stops[i + 1].offset < clampedT) {
+    i++;
+  }
+  const s0 = stops[i];
+  const s1 = stops[i + 1];
+  const span = s1.offset - s0.offset;
+  if (span <= 1e-6) {
+    return s1.color;
+  }
+  let u = (clampedT - s0.offset) / span;
+  if (s0.midpoint !== void 0) {
+    u = gradientMidpointRemap(u, s0.midpoint);
+  }
+  const mixed = _chunkUKCJ43YLcjs.mixColors.call(void 0, s0.color, s1.color, u, { space: _nullishCoalesce(g.interpolation, () => ( "oklab")) });
+  return _nullishCoalesce(mixed, () => ( s0.color));
+}
+function insertGradientStop(g, offset, color) {
+  const clampedOffset = clamp(offset, 0, 1);
+  const stopColor = color !== void 0 ? color : sampleGradient(g, clampedOffset, "light");
+  const used = new Set(g.stops.map((s) => s.id));
+  let idx = 1;
+  while (used.has(`s${idx}`)) idx++;
+  const id = `s${idx}`;
+  const newStop = {
+    id,
+    offset: clampedOffset,
+    color: stopColor
+  };
+  const stops = [...g.stops, newStop];
+  const res = normalizeGradient({ ...g, stops });
+  if ("error" in res) throw new Error(res.error);
+  const added = res.gradient.stops.find((s) => s.id === id);
+  return { gradient: res.gradient, stop: added };
+}
+function listValidIds(g) {
+  return g.stops.map((s) => `"${s.id}"`).join(", ");
+}
+function updateGradientStop(g, id, patch) {
+  const index = g.stops.findIndex((s) => s.id === id);
+  if (index === -1) {
+    throw new Error(`Stop "${id}" not found. Valid stop IDs are: ${listValidIds(g)}.`);
+  }
+  const stops = g.stops.map((s, i) => i === index ? { ...s, ...patch } : s);
+  const res = normalizeGradient({ ...g, stops });
+  if ("error" in res) throw new Error(res.error);
+  return res.gradient;
+}
+function removeGradientStop(g, id) {
+  if (g.stops.length <= 2) {
+    throw new Error("A gradient needs at least 2 stops; add one with add_gradient_stop before removing this one.");
+  }
+  const index = g.stops.findIndex((s) => s.id === id);
+  if (index === -1) {
+    throw new Error(`Stop "${id}" not found. Valid stop IDs are: ${listValidIds(g)}.`);
+  }
+  const stops = g.stops.filter((s) => s.id !== id);
+  const res = normalizeGradient({ ...g, stops });
+  if ("error" in res) throw new Error(res.error);
+  return res.gradient;
+}
+function reverseGradient(g) {
+  const reversedStops = g.stops.map((s) => ({
+    ...s,
+    offset: Math.round((1 - s.offset) * 1e4) / 1e4,
+    midpoint: s.midpoint !== void 0 ? Math.round((1 - s.midpoint) * 1e4) / 1e4 : void 0
+  }));
+  reversedStops.sort((a, b) => a.offset - b.offset);
+  return {
+    ...g,
+    center: g.center ? { ...g.center } : void 0,
+    stops: reversedStops
+  };
+}
+function distributeGradientStops(g) {
+  const n = g.stops.length;
+  const distributed = g.stops.map((s, i) => ({
+    ...s,
+    offset: Math.round(i / (n - 1) * 1e4) / 1e4
+  }));
+  return {
+    ...g,
+    center: g.center ? { ...g.center } : void 0,
+    stops: distributed
+  };
+}
+function formatPercent(fraction) {
+  const pct = Math.round(fraction * 1e3) / 10;
+  return `${pct}%`;
+}
+function gradientToCss(g) {
+  const prefix = g.repeating ? `repeating-${g.type}-gradient` : `${g.type}-gradient`;
+  const parts = [];
+  const interpPrefix = g.interpolation && g.interpolation !== "srgb" ? `in ${g.interpolation} ` : "";
+  if (g.type === "linear") {
+    const angle = g.angle !== void 0 ? `${g.angle}deg` : "180deg";
+    parts.push(`${interpPrefix}${angle}`.trim());
+  } else if (g.type === "radial") {
+    const shape = _nullishCoalesce(g.shape, () => ( "ellipse"));
+    const cx = g.center ? formatPercent(g.center.x) : "50%";
+    const cy = g.center ? formatPercent(g.center.y) : "50%";
+    parts.push(`${interpPrefix}${shape} at ${cx} ${cy}`.trim());
+  } else if (g.type === "conic") {
+    const angle = g.angle !== void 0 ? `from ${g.angle}deg` : "from 0deg";
+    const cx = g.center ? formatPercent(g.center.x) : "50%";
+    const cy = g.center ? formatPercent(g.center.y) : "50%";
+    parts.push(`${interpPrefix}${angle} at ${cx} ${cy}`.trim());
+  }
+  for (let i = 0; i < g.stops.length; i++) {
+    const s = g.stops[i];
+    parts.push(`${s.color} ${formatPercent(s.offset)}`);
+    if (s.midpoint !== void 0 && i < g.stops.length - 1) {
+      const next = g.stops[i + 1];
+      const midOffset = s.offset + (next.offset - s.offset) * s.midpoint;
+      parts.push(formatPercent(midOffset));
+    }
+  }
+  return `${prefix}(${parts.join(", ")})`;
+}
+function gradientToCssFallback(g, steps = 16, scheme = "light") {
+  const prefix = g.repeating ? `repeating-${g.type}-gradient` : `${g.type}-gradient`;
+  const parts = [];
+  if (g.type === "linear") {
+    const angle = g.angle !== void 0 ? `${g.angle}deg` : "180deg";
+    parts.push(angle);
+  } else if (g.type === "radial") {
+    const shape = _nullishCoalesce(g.shape, () => ( "ellipse"));
+    const cx = g.center ? formatPercent(g.center.x) : "50%";
+    const cy = g.center ? formatPercent(g.center.y) : "50%";
+    parts.push(`${shape} at ${cx} ${cy}`);
+  } else if (g.type === "conic") {
+    const angle = g.angle !== void 0 ? `from ${g.angle}deg` : "from 0deg";
+    const cx = g.center ? formatPercent(g.center.x) : "50%";
+    const cy = g.center ? formatPercent(g.center.y) : "50%";
+    parts.push(`${angle} at ${cx} ${cy}`);
+  }
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const color = sampleGradient(g, t, scheme);
+    parts.push(`${color} ${formatPercent(t)}`);
+  }
+  return `${prefix}(${parts.join(", ")})`;
+}
+function splitCssArgs(str) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (char === "(") depth++;
+    else if (char === ")") depth = Math.max(0, depth - 1);
+    if (char === "," && depth === 0) {
+      if (current.trim()) parts.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+function parseCssAngle(val) {
+  const trimmed = val.trim().toLowerCase();
+  if (trimmed.endsWith("deg")) return parseFloat(trimmed);
+  if (trimmed.endsWith("turn")) return parseFloat(trimmed) * 360;
+  if (trimmed.endsWith("rad")) return parseFloat(trimmed) * 180 / Math.PI;
+  if (trimmed.startsWith("to ")) {
+    const dir = trimmed.slice(3).trim();
+    if (dir === "bottom") return 180;
+    if (dir === "top") return 0;
+    if (dir === "right") return 90;
+    if (dir === "left") return 270;
+    if (dir === "bottom right" || dir === "right bottom") return 135;
+    if (dir === "bottom left" || dir === "left bottom") return 225;
+    if (dir === "top right" || dir === "right top") return 45;
+    if (dir === "top left" || dir === "left top") return 315;
+  }
+  const n = parseFloat(trimmed);
+  return Number.isFinite(n) ? n : 180;
+}
+function parseCssGradient(css) {
+  if (typeof css !== "string") return null;
+  const trimmed = css.trim();
+  const match = trimmed.match(/^(repeating-)?(linear|radial|conic)-gradient\s*\(([\s\S]*)\)$/i);
+  if (!match) return null;
+  const repeating = Boolean(match[1]);
+  const type = match[2].toLowerCase();
+  const body = match[3];
+  const rawArgs = splitCssArgs(body);
+  if (rawArgs.length === 0) return null;
+  let angle = type === "linear" ? 180 : 0;
+  let center = type !== "linear" ? { x: 0.5, y: 0.5 } : void 0;
+  let shape = type === "radial" ? "ellipse" : void 0;
+  let interpolation = "srgb";
+  let stopStartIndex = 0;
+  let first = rawArgs[0].trim();
+  const inMatch = first.match(/^in\s+([a-z0-9-]+)\s*(.*)$/i);
+  if (inMatch) {
+    const space = inMatch[1].toLowerCase();
+    if (space === "oklab" || space === "oklch" || space === "srgb" || space === "srgb-linear") {
+      interpolation = space;
+    }
+    first = inMatch[2].trim();
+    if (!first) {
+      stopStartIndex = 1;
+      first = _nullishCoalesce(_optionalChain([rawArgs, 'access', _ => _[1], 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]), () => ( ""));
+    }
+  }
+  if (first) {
+    if (type === "linear") {
+      if (first.endsWith("deg") || first.endsWith("turn") || first.endsWith("rad") || first.startsWith("to ")) {
+        angle = parseCssAngle(first);
+        stopStartIndex = stopStartIndex === 0 ? 1 : 2;
+      }
+    } else if (type === "radial") {
+      if (first.includes("circle") || first.includes("ellipse") || first.includes("at ")) {
+        if (first.includes("circle")) shape = "circle";
+        if (first.includes("ellipse")) shape = "ellipse";
+        const atIdx = first.indexOf("at ");
+        if (atIdx !== -1) {
+          const posParts = first.slice(atIdx + 3).trim().split(/\s+/);
+          if (posParts[0]) center = { x: parsePos(posParts[0]), y: posParts[1] ? parsePos(posParts[1]) : parsePos(posParts[0]) };
+        }
+        stopStartIndex = stopStartIndex === 0 ? 1 : 2;
+      }
+    } else if (type === "conic") {
+      if (first.includes("from ") || first.includes("at ")) {
+        const fromMatch = first.match(/from\s+([0-9.]+(?:deg|turn|rad)?)/i);
+        if (fromMatch) angle = parseCssAngle(fromMatch[1]);
+        const atIdx = first.indexOf("at ");
+        if (atIdx !== -1) {
+          const posParts = first.slice(atIdx + 3).trim().split(/\s+/);
+          if (posParts[0]) center = { x: parsePos(posParts[0]), y: posParts[1] ? parsePos(posParts[1]) : parsePos(posParts[0]) };
+        }
+        stopStartIndex = stopStartIndex === 0 ? 1 : 2;
+      }
+    }
+  }
+  const stopArgs = rawArgs.slice(stopStartIndex);
+  if (stopArgs.length === 0) return null;
+  const items = [];
+  for (const str of stopArgs) {
+    const s = str.trim();
+    if (/^([0-9.]+)%$/.test(s)) {
+      items.push({ kind: "hint", offset: parseFloat(s) / 100 });
+      continue;
+    }
+    const posMatch = s.match(/\s+([0-9.]+)%$/);
+    if (posMatch) {
+      const colorStr = s.slice(0, posMatch.index).trim();
+      const offset = parseFloat(posMatch[1]) / 100;
+      items.push({ kind: "stop", color: colorStr, offset });
+    } else {
+      items.push({ kind: "stop", color: s });
+    }
+  }
+  const rawStops = items.filter((it) => it.kind === "stop");
+  if (rawStops.length < 2) return null;
+  for (let i = 0; i < rawStops.length; i++) {
+    if (rawStops[i].offset === void 0) {
+      if (i === 0) rawStops[i].offset = 0;
+      else if (i === rawStops.length - 1) rawStops[i].offset = 1;
+      else {
+        let nextIdx = i + 1;
+        while (nextIdx < rawStops.length && rawStops[nextIdx].offset === void 0) {
+          nextIdx++;
+        }
+        const nextOffset = nextIdx < rawStops.length ? rawStops[nextIdx].offset : 1;
+        const prevOffset = _nullishCoalesce(rawStops[i - 1].offset, () => ( 0));
+        const count = nextIdx - (i - 1);
+        for (let k = i; k < nextIdx; k++) {
+          rawStops[k].offset = prevOffset + (k - (i - 1)) / count * (nextOffset - prevOffset);
+        }
+        i = nextIdx - 1;
+      }
+    }
+  }
+  const finalStops = [];
+  let stopIdx = 0;
+  for (let i = 0; i < items.length; i++) {
+    const it = items[i];
+    if (it.kind === "stop") {
+      const stop = {
+        id: `s${stopIdx + 1}`,
+        offset: clamp(_nullishCoalesce(it.offset, () => ( 0)), 0, 1),
+        color: it.color
+      };
+      if (i + 1 < items.length && items[i + 1].kind === "hint") {
+        const hintOffset = items[i + 1].offset;
+        const nextStopItem = items.slice(i + 2).find((x) => x.kind === "stop");
+        if (nextStopItem && nextStopItem.offset !== void 0) {
+          const span = nextStopItem.offset - stop.offset;
+          if (span > 0) {
+            stop.midpoint = clamp((hintOffset - stop.offset) / span, 0.05, 0.95);
+          }
+        }
+      }
+      finalStops.push(stop);
+      stopIdx++;
+    }
+  }
+  const res = normalizeGradient({
+    type,
+    angle,
+    center,
+    shape,
+    interpolation,
+    repeating,
+    stops: finalStops
+  });
+  return "gradient" in res ? res.gradient : null;
+}
+function parsePos(str) {
+  const s = str.trim();
+  if (s.endsWith("%")) return clamp(parseFloat(s) / 100, 0, 1);
+  const val = parseFloat(s);
+  return Number.isFinite(val) ? clamp(val, 0, 1) : 0.5;
+}
+function gradientToSvgDef(g, id, scheme = "light") {
+  const steps = 32;
+  const stopsXml = [];
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps;
+    const color = sampleGradient(g, t, scheme);
+    stopsXml.push(`		<stop offset="${formatPercent(t)}" stop-color="${color}" />`);
+  }
+  if (g.type === "radial") {
+    const cx = g.center ? formatPercent(g.center.x) : "50%";
+    const cy = g.center ? formatPercent(g.center.y) : "50%";
+    const r = g.shape === "circle" ? "50%" : "70.7%";
+    return `<radialGradient id="${id}" cx="${cx}" cy="${cy}" r="${r}">
+${stopsXml.join("\n")}
+</radialGradient>`;
+  }
+  if (g.type === "conic") {
+    return `<!-- Note: SVG does not natively support conic gradients; rendering as linear fallback -->
+<linearGradient id="${id}" x1="0%" y1="0%" x2="100%" y2="0%">
+${stopsXml.join("\n")}
+</linearGradient>`;
+  }
+  const angle = _nullishCoalesce(g.angle, () => ( 180));
+  const rad = (90 - angle) * Math.PI / 180;
+  const dx = Math.cos(rad);
+  const dy = -Math.sin(rad);
+  const x1 = formatPercent(0.5 - dx * 0.5);
+  const y1 = formatPercent(0.5 - dy * 0.5);
+  const x2 = formatPercent(0.5 + dx * 0.5);
+  const y2 = formatPercent(0.5 + dy * 0.5);
+  return `<linearGradient id="${id}" x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}">
+${stopsXml.join("\n")}
+</linearGradient>`;
+}
+function checkGradient(g, options = {}) {
+  const dual = isDualGradient(g) || _chunkUKCJ43YLcjs.isDualColor.call(void 0, options.surface) || _chunkUKCJ43YLcjs.isDualColor.call(void 0, options.text);
+  if (dual) {
+    const lightG = resolveGradient(g, "light");
+    const darkG = resolveGradient(g, "dark");
+    const lightText = options.text ? _nullishCoalesce(_chunkUKCJ43YLcjs.resolveColor.call(void 0, options.text, "light"), () => ( void 0)) : void 0;
+    const darkText = options.text ? _nullishCoalesce(_chunkUKCJ43YLcjs.resolveColor.call(void 0, options.text, "dark"), () => ( void 0)) : void 0;
+    const checkScheme = (grad, txt, schemeName) => {
+      const issues2 = [];
+      for (let i = 0; i < grad.stops.length - 1; i++) {
+        const gap = grad.stops[i + 1].offset - grad.stops[i].offset;
+        if (gap < 5e-3) {
+          issues2.push(`[${schemeName}] Stops "${grad.stops[i].id}" and "${grad.stops[i + 1].id}" are too close (gap < 0.005).`);
+        }
+        const c1 = _chunkUKCJ43YLcjs.parseColor.call(void 0, grad.stops[i].color);
+        const c2 = _chunkUKCJ43YLcjs.parseColor.call(void 0, grad.stops[i + 1].color);
+        if (c1 && c2 && gap < 0.05) {
+          const dE = _chunkUKCJ43YLcjs.deltaEOK.call(void 0, c1, c2);
+          if (dE > 0.5) {
+            issues2.push(
+              `[${schemeName}] Banding risk between stops "${grad.stops[i].id}" and "${grad.stops[i + 1].id}" (\u0394EOK = ${dE.toFixed(2)} across gap ${gap.toFixed(3)}).`
+            );
+          }
+        }
+      }
+      for (const s of grad.stops) {
+        const c = _chunkUKCJ43YLcjs.parseColor.call(void 0, s.color);
+        if (c && !_chunkUKCJ43YLcjs.inSrgbGamut.call(void 0, c)) {
+          issues2.push(`[${schemeName}] Stop "${s.id}" colour ${s.color} is outside standard sRGB gamut.`);
+        }
+      }
+      let lowest;
+      if (txt) {
+        const parsedTxt = _chunkUKCJ43YLcjs.parseColor.call(void 0, txt);
+        if (parsedTxt) {
+          let minRatio = Infinity;
+          for (let step = 0; step <= 32; step++) {
+            const sample = _chunkUKCJ43YLcjs.parseColor.call(void 0, sampleGradient(grad, step / 32, schemeName));
+            if (sample) {
+              const r = _chunkUKCJ43YLcjs.contrastRatio.call(void 0, parsedTxt, sample);
+              if (r < minRatio) minRatio = r;
+            }
+          }
+          lowest = Math.round(minRatio * 100) / 100;
+        }
+      }
+      return { issues: issues2, lowest };
+    };
+    const lRes = checkScheme(lightG, lightText, "light");
+    const dRes = checkScheme(darkG, darkText, "dark");
+    return {
+      issues: [...lRes.issues, ...dRes.issues],
+      lowestTextContrast: lRes.lowest !== void 0 && dRes.lowest !== void 0 ? { light: lRes.lowest, dark: dRes.lowest } : void 0
+    };
+  }
+  const issues = [];
+  for (let i = 0; i < g.stops.length - 1; i++) {
+    const gap = g.stops[i + 1].offset - g.stops[i].offset;
+    if (gap < 5e-3) {
+      issues.push(`Stops "${g.stops[i].id}" and "${g.stops[i + 1].id}" are too close (gap < 0.005).`);
+    }
+    const c1 = _chunkUKCJ43YLcjs.parseColor.call(void 0, g.stops[i].color);
+    const c2 = _chunkUKCJ43YLcjs.parseColor.call(void 0, g.stops[i + 1].color);
+    if (c1 && c2 && gap < 0.05) {
+      const dE = _chunkUKCJ43YLcjs.deltaEOK.call(void 0, c1, c2);
+      if (dE > 0.5) {
+        issues.push(
+          `Banding risk between stops "${g.stops[i].id}" and "${g.stops[i + 1].id}" (\u0394EOK = ${dE.toFixed(2)} across gap ${gap.toFixed(3)}).`
+        );
+      }
+    }
+  }
+  for (const s of g.stops) {
+    const c = _chunkUKCJ43YLcjs.parseColor.call(void 0, s.color);
+    if (c && !_chunkUKCJ43YLcjs.inSrgbGamut.call(void 0, c)) {
+      issues.push(`Stop "${s.id}" colour ${s.color} is outside standard sRGB gamut.`);
+    }
+  }
+  let lowestTextContrast;
+  if (options.text) {
+    const parsedTxt = _chunkUKCJ43YLcjs.parseColor.call(void 0, options.text);
+    if (parsedTxt) {
+      let minRatio = Infinity;
+      for (let step = 0; step <= 32; step++) {
+        const sample = _chunkUKCJ43YLcjs.parseColor.call(void 0, sampleGradient(g, step / 32, "light"));
+        if (sample) {
+          const r = _chunkUKCJ43YLcjs.contrastRatio.call(void 0, parsedTxt, sample);
+          if (r < minRatio) minRatio = r;
+        }
+      }
+      lowestTextContrast = Math.round(minRatio * 100) / 100;
+    }
+  }
+  return { issues, lowestTextContrast };
+}
+var GRADIENT_PRESETS = Object.freeze({
+  sunset: {
+    type: "linear",
+    angle: 90,
+    interpolation: "oklab",
+    stops: [
+      { id: "s1", offset: 0, color: "#f97316" },
+      { id: "s2", offset: 1, color: "#ec4899" }
+    ]
+  },
+  ocean: {
+    type: "linear",
+    angle: 180,
+    interpolation: "oklab",
+    stops: [
+      { id: "s1", offset: 0, color: "#06b6d4" },
+      { id: "s2", offset: 1, color: "#3b82f6" }
+    ]
+  },
+  "mono-fade": {
+    type: "linear",
+    angle: 180,
+    interpolation: "oklab",
+    stops: [
+      { id: "s1", offset: 0, color: "#ffffff" },
+      { id: "s2", offset: 1, color: "#000000" }
+    ]
+  },
+  "transparent-fade": {
+    type: "linear",
+    angle: 180,
+    interpolation: "oklab",
+    stops: [
+      { id: "s1", offset: 0, color: "#000000ff" },
+      { id: "s2", offset: 1, color: "#00000000" }
+    ]
+  },
+  aurora: {
+    type: "linear",
+    angle: 135,
+    interpolation: "oklab",
+    stops: [
+      { id: "s1", offset: 0, color: "#10b981" },
+      { id: "s2", offset: 0.5, color: "#06b6d4" },
+      { id: "s3", offset: 1, color: "#8b5cf6" }
+    ]
+  },
+  neon: {
+    type: "linear",
+    angle: 90,
+    interpolation: "oklab",
+    stops: [
+      { id: "s1", offset: 0, color: "#f43f5e" },
+      { id: "s2", offset: 1, color: "#8b5cf6" }
+    ]
+  },
+  radial: {
+    type: "radial",
+    shape: "ellipse",
+    center: { x: 0.5, y: 0.5 },
+    interpolation: "oklab",
+    stops: [
+      { id: "s1", offset: 0, color: "#ffffff" },
+      { id: "s2", offset: 1, color: "#000000" }
+    ]
+  },
+  conic: {
+    type: "conic",
+    angle: 0,
+    center: { x: 0.5, y: 0.5 },
+    interpolation: "oklab",
+    stops: [
+      { id: "s1", offset: 0, color: "#f43f5e" },
+      { id: "s2", offset: 0.33, color: "#eab308" },
+      { id: "s3", offset: 0.66, color: "#06b6d4" },
+      { id: "s4", offset: 1, color: "#f43f5e" }
+    ]
+  }
+});
+
+// src/gradient/controller.ts
+var GRADIENT_TYPES = ["linear", "radial", "conic"];
+var GRADIENT_INTERPOLATIONS = ["oklab", "oklch", "srgb", "srgb-linear"];
+var GRADIENT_SHAPES = ["circle", "ellipse"];
+var GEOMETRY_KEYS = ["type", "angle", "shape", "interpolation", "repeating"];
+function geometryError(patch) {
+  const list = (values) => values.map((v) => `"${v}"`).join(", ");
+  if (patch.type !== void 0 && !GRADIENT_TYPES.includes(patch.type)) {
+    return `Unknown gradient type "${String(patch.type)}"; use one of ${list(GRADIENT_TYPES)}.`;
+  }
+  if (patch.angle !== void 0 && (typeof patch.angle !== "number" || !Number.isFinite(patch.angle))) {
+    return `The angle must be a finite number of degrees; got ${String(patch.angle)}.`;
+  }
+  if (patch.center !== void 0) {
+    const c = patch.center;
+    const inRange = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= 1;
+    if (!c || typeof c !== "object" || !inRange(c.x) || !inRange(c.y)) {
+      return `The center needs x and y between 0 and 1; got ${JSON.stringify(patch.center)}.`;
+    }
+  }
+  if (patch.shape !== void 0 && !GRADIENT_SHAPES.includes(patch.shape)) {
+    return `Unknown radial shape "${String(patch.shape)}"; use ${list(GRADIENT_SHAPES)}.`;
+  }
+  if (patch.interpolation !== void 0 && !GRADIENT_INTERPOLATIONS.includes(patch.interpolation)) {
+    return `Unknown interpolation "${String(patch.interpolation)}"; use one of ${list(GRADIENT_INTERPOLATIONS)}.`;
+  }
+  if (patch.repeating !== void 0 && typeof patch.repeating !== "boolean") {
+    return `"repeating" must be true or false; got ${String(patch.repeating)}.`;
+  }
+  return null;
+}
+function sameGradientJson(a, b) {
+  if (a === b) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return Number.isNaN(a) && Number.isNaN(b);
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const bb = b;
+    return a.length === bb.length && a.every((v, i) => sameGradientJson(v, bb[i]));
+  }
+  const ao = a;
+  const bo = b;
+  const keys = Object.keys(ao).filter((k) => ao[k] !== void 0);
+  if (keys.length !== Object.keys(bo).filter((k) => bo[k] !== void 0).length) return false;
+  return keys.every((k) => Object.prototype.hasOwnProperty.call(bo, k) && sameGradientJson(ao[k], bo[k]));
+}
+var GradientController = (_class = class {
+  
+  __init() {this._selectedStopId = null}
+  
+  
+  
+  __init2() {this._listeners = /* @__PURE__ */ new Set()}
+  __init3() {this._gestureKey = null}
+  __init4() {this._gestureCount = 0}
+  __init5() {this._revision = 0}
+  __init6() {this._cachedState = null}
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);
+    if (options.value !== void 0) {
+      const norm = normalizeGradient(options.value);
+      if ("error" in norm) throw new Error(norm.error);
+      this._gradient = norm.gradient;
+    } else {
+      this._gradient = createGradient(["#000000", "#ffffff"]);
+    }
+    this._history = _nullishCoalesce(options.history, () => ( new (0, _chunkFJ2MSI43cjs.HistoryManager)()));
+    this._readOnlyOption = options.readOnly;
+    this._onChange = options.onChange;
+    if (this._gradient.stops.length > 0) {
+      this._selectedStopId = this._gradient.stops[0].id;
+    }
+  }
+  get state() {
+    if (this._cachedState && this._cachedState.revision === this._revision) {
+      const hState2 = this._history.getState();
+      if (this._cachedState.canUndo === hState2.canUndo && this._cachedState.canRedo === hState2.canRedo && this._cachedState.undoLabel === hState2.undoName && this._cachedState.redoLabel === hState2.redoName && this._cachedState.selectedStopId === this._selectedStopId && this._cachedState.gradient === this._gradient) {
+        return this._cachedState;
+      }
+    }
+    const hState = this._history.getState();
+    this._cachedState = {
+      gradient: this._gradient,
+      selectedStopId: this._selectedStopId,
+      canUndo: hState.canUndo,
+      canRedo: hState.canRedo,
+      undoLabel: hState.undoName,
+      redoLabel: hState.redoName,
+      revision: this._revision
+    };
+    return this._cachedState;
+  }
+  get readOnlyReason() {
+    const r = typeof this._readOnlyOption === "function" ? this._readOnlyOption() : this._readOnlyOption;
+    if (!r) return null;
+    return typeof r === "string" ? r : "The gradient is read-only.";
+  }
+  get isReadOnly() {
+    return this.readOnlyReason !== null;
+  }
+  getGradient() {
+    return this._gradient;
+  }
+  getSelectedStopId() {
+    return this._selectedStopId;
+  }
+  getSelectedStop() {
+    if (!this._selectedStopId) return null;
+    return _nullishCoalesce(this._gradient.stops.find((s) => s.id === this._selectedStopId), () => ( null));
+  }
+  subscribe(fn) {
+    this._listeners.add(fn);
+    try {
+      fn(this.state);
+    } catch (err) {
+      console.error("GradientController subscriber error", err);
+    }
+    return () => {
+      this._listeners.delete(fn);
+    };
+  }
+  /** `changed` is false for view-only updates (selection), which don't call `onChange`. */
+  _notify(changed = true) {
+    this._revision++;
+    const s = this.state;
+    for (const fn of this._listeners) {
+      try {
+        fn(s);
+      } catch (err) {
+        console.error("GradientController subscriber error", err);
+      }
+    }
+    if (changed && this._onChange) {
+      try {
+        this._onChange(this._gradient);
+      } catch (err) {
+        console.error("GradientController onChange error", err);
+      }
+    }
+  }
+  _checkReadOnly() {
+    const reason = this.readOnlyReason;
+    if (reason) {
+      return { ok: false, message: reason };
+    }
+    return null;
+  }
+  /** Selects a stop (view state; not an undo step and no `onChange`). Unknown ids are ignored. */
+  selectStop(stopId) {
+    if (stopId !== null && !this._gradient.stops.some((s) => s.id === stopId)) {
+      return;
+    }
+    if (this._selectedStopId !== stopId) {
+      this._selectedStopId = stopId;
+      this._notify(false);
+    }
+  }
+  beginGesture(label = "Edit Gradient") {
+    if (this._gestureKey === label) return;
+    this._history.endGesture();
+    this._gestureKey = label;
+    this._gestureCount++;
+  }
+  endGesture() {
+    this._gestureKey = null;
+    this._history.endGesture();
+  }
+  _apply(newGradient, label, newStopId = this._selectedStopId) {
+    const ro = this._checkReadOnly();
+    if (ro) return ro;
+    if (newStopId !== null && !newGradient.stops.some((s) => s.id === newStopId)) {
+      newStopId = _nullishCoalesce(_optionalChain([newGradient, 'access', _4 => _4.stops, 'access', _5 => _5[0], 'optionalAccess', _6 => _6.id]), () => ( null));
+    }
+    if (sameGradientJson(this._gradient, newGradient) && this._selectedStopId === newStopId) {
+      return { ok: true };
+    }
+    const beforeGradient = this._gradient;
+    const beforeStopId = this._selectedStopId;
+    const cmd = {
+      name: label,
+      tag: "gradient",
+      execute: () => {
+        this._gradient = newGradient;
+        this._selectedStopId = newStopId;
+        this._notify();
+      },
+      undo: () => {
+        this._gradient = beforeGradient;
+        this._selectedStopId = beforeStopId;
+        this._notify();
+      }
+    };
+    if (this._gestureKey !== null) {
+      this._history.executeMerged(cmd, { key: `gradient.gesture:${this._gestureKey}:${this._gestureCount}` });
+    } else {
+      this._history.execute(cmd);
+    }
+    return { ok: true };
+  }
+  /** The selected stop after `next` replaces the gradient: same id if it survives, else same index. */
+  _selectionAfterReplace(next) {
+    if (this._selectedStopId === null) return null;
+    if (next.stops.some((s) => s.id === this._selectedStopId)) return this._selectedStopId;
+    const index = this._gradient.stops.findIndex((s) => s.id === this._selectedStopId);
+    return _nullishCoalesce(_optionalChain([next, 'access', _7 => _7.stops, 'access', _8 => _8[Math.min(Math.max(index, 0), next.stops.length - 1)], 'optionalAccess', _9 => _9.id]), () => ( null));
+  }
+  setGradient(value, label = "Set Gradient") {
+    const norm = normalizeGradient(value);
+    if ("error" in norm) {
+      return { ok: false, message: norm.error };
+    }
+    return this._apply(norm.gradient, label, this._selectionAfterReplace(norm.gradient));
+  }
+  /**
+   * Replaces the gradient without an undo step (e.g. syncing a controlled `value` from the
+   * host). Keeps the selection when the stop survives. Notifies subscribers and `onChange`.
+   */
+  load(value, options = {}) {
+    const norm = normalizeGradient(value);
+    if ("error" in norm) {
+      return { ok: false, message: norm.error };
+    }
+    const nextStopId = this._selectionAfterReplace(norm.gradient);
+    if (options.clearHistory) this._history.clear();
+    if (sameGradientJson(this._gradient, norm.gradient) && this._selectedStopId === nextStopId) {
+      return { ok: true };
+    }
+    this._gradient = norm.gradient;
+    this._selectedStopId = nextStopId;
+    this._notify();
+    return { ok: true };
+  }
+  /**
+   * Changes any of type, angle, center, shape, interpolation and repeating as one undo step.
+   * Every field is checked before anything changes; an invalid one fails the whole call.
+   */
+  setGeometry(patch, label = "Change Gradient Geometry") {
+    const ro = this._checkReadOnly();
+    if (ro) return ro;
+    const error = geometryError(patch);
+    if (error) return { ok: false, message: error };
+    const merged = { ...this._gradient };
+    for (const key of GEOMETRY_KEYS) {
+      if (patch[key] !== void 0) merged[key] = patch[key];
+    }
+    if (patch.center) merged.center = { ...patch.center };
+    if (patch.shape !== void 0 && merged.type !== "radial") {
+      return { ok: false, message: `The shape applies to radial gradients only; this one is ${merged.type}. Set type "radial" too.` };
+    }
+    if (patch.center !== void 0 && merged.type === "linear") {
+      return { ok: false, message: "The center applies to radial and conic gradients only; this one is linear." };
+    }
+    if (patch.angle !== void 0 && merged.type === "radial") {
+      return { ok: false, message: "The angle applies to linear and conic gradients only; this one is radial." };
+    }
+    const norm = normalizeGradient(merged);
+    if ("error" in norm) return { ok: false, message: norm.error };
+    return this._apply(norm.gradient, label);
+  }
+  setType(type) {
+    return this.setGeometry({ type }, "Change Gradient Type");
+  }
+  setAngle(angle) {
+    return this.setGeometry({ angle }, "Change Gradient Angle");
+  }
+  setCenter(center) {
+    return this.setGeometry({ center }, "Change Gradient Center");
+  }
+  setShape(shape) {
+    return this.setGeometry({ shape }, "Change Gradient Shape");
+  }
+  setInterpolation(interpolation) {
+    return this.setGeometry({ interpolation }, "Change Gradient Interpolation");
+  }
+  setRepeating(repeating) {
+    return this.setGeometry({ repeating }, "Toggle Gradient Repeating");
+  }
+  addStop(offset, color) {
+    const ro = this._checkReadOnly();
+    if (ro) return { ok: false, message: ro.message };
+    try {
+      const { gradient: next, stop } = insertGradientStop(this._gradient, offset, color);
+      const res = this._apply(next, "Add Gradient Stop", stop.id);
+      if (!res.ok) return res;
+      return { ok: true, stop };
+    } catch (e) {
+      return { ok: false, message: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  updateStop(id, patch) {
+    const ro = this._checkReadOnly();
+    if (ro) return ro;
+    try {
+      const next = updateGradientStop(this._gradient, id, patch);
+      return this._apply(next, "Update Gradient Stop");
+    } catch (e) {
+      return { ok: false, message: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  removeStop(id) {
+    const ro = this._checkReadOnly();
+    if (ro) return ro;
+    try {
+      const next = removeGradientStop(this._gradient, id);
+      return this._apply(next, "Remove Gradient Stop");
+    } catch (e) {
+      return { ok: false, message: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  reverse() {
+    const ro = this._checkReadOnly();
+    if (ro) return ro;
+    const next = reverseGradient(this._gradient);
+    return this._apply(next, "Reverse Gradient");
+  }
+  distribute() {
+    const ro = this._checkReadOnly();
+    if (ro) return ro;
+    const next = distributeGradientStops(this._gradient);
+    return this._apply(next, "Distribute Gradient Stops");
+  }
+  undo() {
+    if (this.isReadOnly || !this._history.getState().canUndo) return false;
+    return this._history.undo();
+  }
+  redo() {
+    if (this.isReadOnly || !this._history.getState().canRedo) return false;
+    return this._history.redo();
+  }
+  dispose() {
+    this._listeners.clear();
+  }
+}, _class);
+
+// src/gradient/tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var readTool = (title) => ({ ...READ, title });
+var writeTool = (title, destructive = false) => ({ ...WRITE, destructiveHint: destructive, title });
+var writeIdempotentTool = (title) => ({ ...WRITE_IDEMPOTENT, title });
+var fail = (message) => {
+  throw new Error(message);
+};
+function createGradientToolProvider(controller, options = {}) {
+  const readOnlyReason = () => {
+    const r = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    if (r) return typeof r === "string" ? r : "The gradient is read-only.";
+    return controller.readOnlyReason;
+  };
+  const tools = [
+    {
+      name: "get_gradient",
+      title: "Get Gradient",
+      description: "Returns the current gradient model, its CSS string representation, SVG definition markup, whether it contains light-dark() dual colours, and the currently selected stop id.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      annotations: readTool("Get Gradient"),
+      handler: async () => {
+        const g = controller.getGradient();
+        const ro = readOnlyReason();
+        return {
+          gradient: g,
+          css: gradientToCss(g),
+          svgDef: gradientToSvgDef(g, "gradient-preview"),
+          isDual: isDualGradient(g),
+          selectedStopId: controller.getSelectedStopId(),
+          readOnly: ro !== null,
+          ...ro ? { readOnlyReason: ro } : {}
+        };
+      }
+    },
+    {
+      name: "check_gradient",
+      title: "Check Gradient",
+      description: "Evaluates the current gradient for perceptual defects: stops placed too close causing sharp edges, out-of-gamut colours in sRGB, color banding risks, and contrast against background or text across the gradient ramp.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          surface: {
+            description: "Optional background/surface colour to evaluate contrast against."
+          },
+          text: {
+            description: "Optional text colour to evaluate WCAG 2.1 AA/AAA contrast against across all points on the gradient ramp."
+          },
+          fontSize: {
+            type: "number",
+            description: "Font size in points or pixels for WCAG text contrast threshold calculation (default 14)."
+          },
+          bold: {
+            type: "boolean",
+            description: "Whether the text is bold for WCAG threshold calculation."
+          }
+        },
+        additionalProperties: false
+      },
+      annotations: readTool("Check Gradient"),
+      handler: async (args) => {
+        const g = controller.getGradient();
+        const checkOpts = {};
+        if (args.surface !== void 0) checkOpts.surface = args.surface;
+        if (args.text !== void 0) checkOpts.text = args.text;
+        if (typeof args.fontSize === "number") checkOpts.fontSize = args.fontSize;
+        if (typeof args.bold === "boolean") checkOpts.bold = args.bold;
+        const res = checkGradient(g, checkOpts);
+        return {
+          pass: res.issues.length === 0,
+          issueCount: res.issues.length,
+          ...res
+        };
+      }
+    },
+    {
+      name: "list_gradient_presets",
+      title: "List Gradient Presets",
+      description: "Returns the collection of built-in gradient presets with their name, category, and CSS representations.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      annotations: readTool("List Gradient Presets"),
+      handler: async () => {
+        return {
+          presets: Object.entries(GRADIENT_PRESETS).map(([id, gradient]) => ({
+            id,
+            name: id,
+            css: gradientToCss(gradient),
+            gradient
+          }))
+        };
+      }
+    }
+  ];
+  if (!readOnlyReason()) {
+    tools.push(
+      {
+        name: "set_gradient",
+        title: "Set Gradient",
+        description: 'Replaces the entire gradient with a new gradient object or a standard CSS gradient string (e.g. "linear-gradient(90deg, #ff0000, #0000ff)"). Exactly one of "gradient" or "css" must be provided.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            gradient: {
+              type: "object",
+              description: "Gradient object with stops, type, angle, etc."
+            },
+            css: {
+              type: "string",
+              description: "CSS gradient string to parse and apply."
+            }
+          },
+          oneOf: [
+            { required: ["gradient"] },
+            { required: ["css"] }
+          ],
+          additionalProperties: false
+        },
+        annotations: writeIdempotentTool("Set Gradient"),
+        handler: async (args) => {
+          if (args.gradient !== void 0 && args.css !== void 0) {
+            fail('Provide either "gradient" or "css", not both.');
+          }
+          if (args.gradient === void 0 && args.css === void 0) {
+            fail('Provide either "gradient" or "css".');
+          }
+          const val = args.gradient !== void 0 ? args.gradient : args.css;
+          const res = controller.setGradient(val);
+          if (!res.ok) fail(res.message);
+          const current = controller.getGradient();
+          return {
+            gradient: current,
+            css: gradientToCss(current)
+          };
+        }
+      },
+      {
+        name: "set_gradient_geometry",
+        title: "Set Gradient Geometry",
+        description: "Updates the geometry of the gradient: type (linear/radial/conic), angle in degrees, center (0 to 1), shape (circle/ellipse), interpolation space or repeating mode. Pass only the fields to change. All fields are checked first and applied as one undo step; an invalid field (e.g. shape on a linear gradient) changes nothing. Returns the resulting gradient and its CSS.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            type: {
+              type: "string",
+              enum: ["linear", "radial", "conic"],
+              description: "The geometry type of the gradient."
+            },
+            angle: {
+              type: "number",
+              description: "The angle in degrees for linear or conic gradients (0 = up/top, 90 = right)."
+            },
+            center: {
+              type: "object",
+              description: "Center { x, y } as fractions of the box (0 to 1) for radial or conic gradients. Default { x: 0.5, y: 0.5 }.",
+              properties: {
+                x: { type: "number", minimum: 0, maximum: 1, description: "Horizontal center, 0 (left) to 1 (right)." },
+                y: { type: "number", minimum: 0, maximum: 1, description: "Vertical center, 0 (top) to 1 (bottom)." }
+              },
+              required: ["x", "y"],
+              additionalProperties: false
+            },
+            shape: {
+              type: "string",
+              enum: ["circle", "ellipse"],
+              description: "Radial gradient shape."
+            },
+            interpolation: {
+              type: "string",
+              enum: [...GRADIENT_INTERPOLATIONS],
+              description: 'Colour interpolation space. "oklab" (the default) gives smooth perceptual blends; "oklch" keeps chroma through hue changes.'
+            },
+            repeating: {
+              type: "boolean",
+              description: "Whether the gradient pattern repeats outside the defined stops."
+            }
+          },
+          minProperties: 1,
+          additionalProperties: false
+        },
+        annotations: writeIdempotentTool("Set Gradient Geometry"),
+        handler: async (args) => {
+          if (!["type", "angle", "center", "shape", "interpolation", "repeating"].some((k) => args[k] !== void 0)) {
+            fail("Pass at least one of type, angle, center, shape, interpolation or repeating.");
+          }
+          const r = controller.setGeometry(
+            {
+              type: args.type,
+              angle: args.angle,
+              center: args.center,
+              shape: args.shape,
+              interpolation: args.interpolation,
+              repeating: args.repeating
+            },
+            "Update Gradient Geometry"
+          );
+          if (!r.ok) fail(r.message);
+          const current = controller.getGradient();
+          return {
+            gradient: current,
+            css: gradientToCss(current)
+          };
+        }
+      },
+      {
+        name: "add_gradient_stop",
+        title: "Add Gradient Stop",
+        description: "Adds a new color stop to the gradient. If color is not specified, it is sampled from the gradient at that offset.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            offset: {
+              type: "number",
+              description: "Offset along the gradient ramp from 0 to 1."
+            },
+            color: {
+              type: "string",
+              description: "CSS color string, hex, hsl, oklch, or light-dark() expression for the stop."
+            }
+          },
+          required: ["offset"],
+          additionalProperties: false
+        },
+        annotations: writeTool("Add Gradient Stop"),
+        handler: async (args) => {
+          const res = controller.addStop(args.offset, args.color);
+          if (!res.ok) fail(res.message);
+          return {
+            stop: res.stop,
+            gradient: controller.getGradient(),
+            css: gradientToCss(controller.getGradient())
+          };
+        }
+      },
+      {
+        name: "update_gradient_stop",
+        title: "Update Gradient Stop",
+        description: "Updates an existing color stop: changes its color, its offset (position 0..1), or its transition midpoint (0..1).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "ID of the stop to update."
+            },
+            color: {
+              type: "string",
+              description: "New color string."
+            },
+            offset: {
+              type: "number",
+              description: "New offset between 0 and 1."
+            },
+            midpoint: {
+              type: "number",
+              description: "Transition midpoint to the next stop (0 to 1, default 0.5)."
+            }
+          },
+          required: ["id"],
+          additionalProperties: false
+        },
+        annotations: writeIdempotentTool("Update Gradient Stop"),
+        handler: async (args) => {
+          const patch = {};
+          if (args.color !== void 0) patch.color = args.color;
+          if (args.offset !== void 0) patch.offset = args.offset;
+          if (args.midpoint !== void 0) patch.midpoint = args.midpoint;
+          const res = controller.updateStop(args.id, patch);
+          if (!res.ok) fail(res.message);
+          return {
+            stop: controller.getGradient().stops.find((s) => s.id === args.id),
+            gradient: controller.getGradient(),
+            css: gradientToCss(controller.getGradient())
+          };
+        }
+      },
+      {
+        name: "remove_gradient_stop",
+        title: "Remove Gradient Stop",
+        description: "Removes a color stop by its ID. Gradients must retain at least two stops.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: "ID of the stop to remove."
+            }
+          },
+          required: ["id"],
+          additionalProperties: false
+        },
+        annotations: writeTool("Remove Gradient Stop", true),
+        handler: async (args) => {
+          const res = controller.removeStop(args.id);
+          if (!res.ok) fail(res.message);
+          return {
+            removedId: args.id,
+            gradient: controller.getGradient(),
+            css: gradientToCss(controller.getGradient())
+          };
+        }
+      },
+      {
+        name: "reverse_gradient",
+        title: "Reverse Gradient",
+        description: "Reverses the order and offsets of all stops in the gradient ramp.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        annotations: writeTool("Reverse Gradient"),
+        handler: async () => {
+          const res = controller.reverse();
+          if (!res.ok) fail(res.message);
+          return {
+            gradient: controller.getGradient(),
+            css: gradientToCss(controller.getGradient())
+          };
+        }
+      },
+      {
+        name: "distribute_gradient_stops",
+        title: "Distribute Gradient Stops",
+        description: "Evenly distributes all color stops between 0 and 1 along the gradient ramp.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        },
+        annotations: writeTool("Distribute Gradient Stops"),
+        handler: async () => {
+          const res = controller.distribute();
+          if (!res.ok) fail(res.message);
+          return {
+            gradient: controller.getGradient(),
+            css: gradientToCss(controller.getGradient())
+          };
+        }
+      },
+      {
+        name: "apply_gradient_preset",
+        title: "Apply Gradient Preset",
+        description: "Applies one of the built-in gradient presets by its ID.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: 'Preset ID (e.g. "sunset", "ocean", "neon-glow", "mesh-aurora").'
+            }
+          },
+          required: ["id"],
+          additionalProperties: false
+        },
+        annotations: writeIdempotentTool("Apply Gradient Preset"),
+        handler: async (args) => {
+          const gradient = GRADIENT_PRESETS[args.id];
+          if (!gradient) {
+            fail(`Unknown gradient preset "${args.id}". Use list_gradient_presets to inspect available presets.`);
+          }
+          const res = controller.setGradient(gradient, `Apply Preset: ${args.id}`);
+          if (!res.ok) fail(res.message);
+          return {
+            preset: args.id,
+            gradient: controller.getGradient(),
+            css: gradientToCss(controller.getGradient())
+          };
+        }
+      }
+    );
+  }
+  return {
+    id: _nullishCoalesce(options.id, () => ( "gradient")),
+    namespace: options.namespace !== void 0 ? options.namespace : _nullishCoalesce(options.id, () => ( "gradient")),
+    title: "Gradient",
+    description: "Inspect, edit, validate, and check colour gradients.",
+    skill: "pixerate-color",
+    tools: () => tools
+  };
+}
+
+// src/gradient/editor.ts
+function stopFromTrackPosition(g, x) {
+  return Math.max(0, Math.min(1, Math.round(x * 1e3) / 1e3));
+}
+function trackPositionFromStop(stop) {
+  return Math.max(0, Math.min(1, stop.offset));
+}
+function gradientKeyStep(g, id, key, shift = false) {
+  const stop = g.stops.find((s) => s.id === id);
+  if (!stop) return null;
+  const step = shift ? 0.1 : 0.01;
+  switch (key) {
+    case "ArrowLeft":
+    case "ArrowDown": {
+      const offset = Math.max(0, Math.round((stop.offset - step) * 1e3) / 1e3);
+      return { stopId: id, offset };
+    }
+    case "ArrowRight":
+    case "ArrowUp": {
+      const offset = Math.min(1, Math.round((stop.offset + step) * 1e3) / 1e3);
+      return { stopId: id, offset };
+    }
+    case "Delete":
+    case "Backspace": {
+      return { stopId: id, remove: true };
+    }
+    default:
+      return null;
+  }
+}
+function angleFromPointer(center, point, snapStep) {
+  const dx = point.x - center.x;
+  const dy = point.y - center.y;
+  let deg = Math.atan2(dx, -dy) * 180 / Math.PI;
+  if (deg < 0) deg += 360;
+  if (snapStep && snapStep > 0) {
+    deg = Math.round(deg / snapStep) * snapStep;
+    if (deg >= 360) deg -= 360;
+  }
+  return Math.round(deg);
+}
+function gradientTrackBackground(g) {
+  const linearCopy = {
+    ...g,
+    type: "linear",
+    angle: 90
+  };
+  return gradientToCss(linearCopy);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.GRADIENT_INTERPOLATIONS = GRADIENT_INTERPOLATIONS; exports.GRADIENT_PRESETS = GRADIENT_PRESETS; exports.GRADIENT_TYPES = GRADIENT_TYPES; exports.GradientController = GradientController; exports.angleFromPointer = angleFromPointer; exports.checkGradient = checkGradient; exports.createGradient = createGradient; exports.createGradientToolProvider = createGradientToolProvider; exports.distributeGradientStops = distributeGradientStops; exports.gradientKeyStep = gradientKeyStep; exports.gradientMidpointRemap = gradientMidpointRemap; exports.gradientToCss = gradientToCss; exports.gradientToCssFallback = gradientToCssFallback; exports.gradientToSvgDef = gradientToSvgDef; exports.gradientTrackBackground = gradientTrackBackground; exports.insertGradientStop = insertGradientStop; exports.isDualColorValue = isDualColorValue; exports.isDualGradient = isDualGradient; exports.normalizeGradient = normalizeGradient; exports.parseCssGradient = parseCssGradient; exports.removeGradientStop = removeGradientStop; exports.resolveGradient = resolveGradient; exports.reverseGradient = reverseGradient; exports.sampleGradient = sampleGradient; exports.stopFromTrackPosition = stopFromTrackPosition; exports.trackPositionFromStop = trackPositionFromStop; exports.updateGradientStop = updateGradientStop;