@absolutejs/ai 0.0.32 → 0.0.34

package/dist/ai/ui/index.js

@@ -0,0 +1,604 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, name) => {
+  Object.defineProperty(target, "name", {
+    value: name,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+};
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
+    done._ = 1;
+    if (k ^ 4 || it === undefined)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+
+// src/ai/ui/uiCards.ts
+var createUiCards = (definitions) => {
+  const byName = new Map(definitions.map((definition) => [definition.name, definition]));
+  const tools = Object.fromEntries(definitions.map((definition) => [
+    definition.name,
+    {
+      description: definition.description,
+      handler: () => definition.ack,
+      input: definition.inputSchema
+    }
+  ]));
+  const collect = (calls) => {
+    const events = [];
+    for (const call of calls) {
+      const definition = byName.get(call.name);
+      if (!definition)
+        continue;
+      const data = definition.parse(call.input);
+      if (data !== null)
+        events.push({ card: definition.name, data });
+    }
+    return events;
+  };
+  return { collect, has: (name) => byName.has(name), tools };
+};
+// src/ai/ui/catalog.ts
+var CHART_TYPES = ["bar", "line", "donut"];
+var CHART_MAX_SERIES = 8;
+var CHART_MAX_POINTS = 24;
+var TABLE_MAX_COLUMNS = 8;
+var TABLE_MAX_ROWS = 30;
+var STAT_TILES_MAX = 6;
+var UI_ACTIONS_MAX = 3;
+var LABEL_MAX_CHARS = 80;
+var TITLE_MAX_CHARS = 120;
+var CELL_MAX_CHARS = 160;
+var UNIT_MAX_CHARS = 8;
+var ACTION_LABEL_MAX_CHARS = 40;
+var ACTION_TOOL_PATTERN = /^[a-z][a-z0-9_]{1,63}$/;
+var isRecord = (value) => typeof value === "object" && value !== null;
+var cleanString = (value, maxChars) => typeof value === "string" && value.trim().length > 0 ? value.trim().slice(0, maxChars) : null;
+var cleanStringArray = (value, maxItems, maxChars) => {
+  if (!Array.isArray(value) || value.length === 0)
+    return null;
+  const cleaned = [];
+  for (const entry of value.slice(0, maxItems)) {
+    const text = cleanString(entry, maxChars);
+    cleaned.push(text ?? "");
+  }
+  return cleaned;
+};
+var cleanNumberArray = (value, maxItems) => {
+  if (!Array.isArray(value) || value.length === 0)
+    return null;
+  const cleaned = [];
+  for (const entry of value.slice(0, maxItems)) {
+    if (typeof entry !== "number" || !Number.isFinite(entry))
+      return null;
+    cleaned.push(entry);
+  }
+  return cleaned;
+};
+var parseUiActions = (value) => {
+  if (!Array.isArray(value) || value.length === 0)
+    return;
+  const actions = [];
+  for (const raw of value.slice(0, UI_ACTIONS_MAX)) {
+    if (!isRecord(raw))
+      continue;
+    const label = cleanString(raw.label, ACTION_LABEL_MAX_CHARS);
+    const tool = typeof raw.tool === "string" && ACTION_TOOL_PATTERN.test(raw.tool) ? raw.tool : null;
+    if (!label || !tool || !isRecord(raw.input))
+      continue;
+    actions.push({ input: raw.input, label, tool });
+  }
+  return actions.length > 0 ? actions : undefined;
+};
+var ACTIONS_SCHEMA = {
+  description: "Optional action buttons under the card (max 3): each invokes one of YOUR tools with a fully-resolved input when the member clicks it. Use real ids you looked up — never placeholders. Approval-gated tools queue their normal approval card.",
+  items: {
+    properties: {
+      input: {
+        description: "The exact tool input to send on click",
+        type: "object"
+      },
+      label: {
+        description: 'Short button label, e.g. "Create follow-up task"',
+        type: "string"
+      },
+      tool: { description: "The tool name to invoke", type: "string" }
+    },
+    required: ["label", "tool", "input"],
+    type: "object"
+  },
+  type: "array"
+};
+var parseChartSpec = (input) => {
+  if (!isRecord(input))
+    return null;
+  const type = CHART_TYPES.find((entry) => entry === input.type);
+  const title = cleanString(input.title, TITLE_MAX_CHARS);
+  const labels = cleanStringArray(input.labels, CHART_MAX_POINTS, LABEL_MAX_CHARS);
+  if (!type || !title || !labels)
+    return null;
+  if (!Array.isArray(input.series) || input.series.length === 0)
+    return null;
+  const series = [];
+  for (const raw of input.series.slice(0, CHART_MAX_SERIES)) {
+    if (!isRecord(raw))
+      return null;
+    const name = cleanString(raw.name, LABEL_MAX_CHARS);
+    const values = cleanNumberArray(raw.values, CHART_MAX_POINTS);
+    if (!name || !values)
+      return null;
+    if (values.length !== labels.length)
+      return null;
+    series.push({ name, values });
+  }
+  if (type === "donut") {
+    const [only] = series;
+    if (series.length !== 1 || !only)
+      return null;
+    if (only.values.some((value) => value < 0))
+      return null;
+  }
+  const spec = { labels, series, title, type };
+  const unitPrefix = cleanString(input.unitPrefix, UNIT_MAX_CHARS);
+  const unitSuffix = cleanString(input.unitSuffix, UNIT_MAX_CHARS);
+  if (unitPrefix)
+    spec.unitPrefix = unitPrefix;
+  if (unitSuffix)
+    spec.unitSuffix = unitSuffix;
+  const actions = parseUiActions(input.actions);
+  if (actions)
+    spec.actions = actions;
+  return spec;
+};
+var parseTableSpec = (input) => {
+  if (!isRecord(input))
+    return null;
+  const columns = cleanStringArray(input.columns, TABLE_MAX_COLUMNS, LABEL_MAX_CHARS);
+  if (!columns)
+    return null;
+  if (!Array.isArray(input.rows) || input.rows.length === 0)
+    return null;
+  const rows = [];
+  for (const raw of input.rows.slice(0, TABLE_MAX_ROWS)) {
+    const cells = cleanStringArray(raw, TABLE_MAX_COLUMNS, CELL_MAX_CHARS);
+    if (!cells)
+      return null;
+    while (cells.length < columns.length)
+      cells.push("");
+    rows.push(cells.slice(0, columns.length));
+  }
+  const spec = { columns, rows };
+  const title = cleanString(input.title, TITLE_MAX_CHARS);
+  if (title)
+    spec.title = title;
+  const actions = parseUiActions(input.actions);
+  if (actions)
+    spec.actions = actions;
+  return spec;
+};
+var parseStatTilesSpec = (input) => {
+  if (!isRecord(input))
+    return null;
+  if (!Array.isArray(input.tiles) || input.tiles.length === 0)
+    return null;
+  const tiles = [];
+  for (const raw of input.tiles.slice(0, STAT_TILES_MAX)) {
+    if (!isRecord(raw))
+      return null;
+    const label = cleanString(raw.label, LABEL_MAX_CHARS);
+    const value = cleanString(raw.value, LABEL_MAX_CHARS);
+    if (!label || !value)
+      return null;
+    const tile = { label, value };
+    const delta = cleanString(raw.delta, LABEL_MAX_CHARS);
+    if (delta)
+      tile.delta = delta;
+    if (raw.deltaDirection === "up" || raw.deltaDirection === "down" || raw.deltaDirection === "flat") {
+      tile.deltaDirection = raw.deltaDirection;
+    }
+    tiles.push(tile);
+  }
+  const spec = { tiles };
+  const actions = parseUiActions(input.actions);
+  if (actions)
+    spec.actions = actions;
+  return spec;
+};
+var SERIES_SCHEMA = {
+  properties: {
+    name: { description: "Series name (shown in the legend)", type: "string" },
+    values: {
+      description: "One number per label, same order as labels",
+      items: { type: "number" },
+      type: "array"
+    }
+  },
+  required: ["name", "values"],
+  type: "object"
+};
+var chartCard = {
+  ack: "(chart rendered inline — do not repeat its numbers as text; add at most a 1-2 line takeaway)",
+  description: "Render a real chart inline in the chat from data you have (tool results, the conversation). Use whenever numbers COMPARE or TREND: revenue by partner (bar), pipeline over time (line), share of a whole (donut). Rules: bar/line take up to 8 series aligned to the same labels; donut takes exactly ONE series of non-negative values (one slice per label). Prefer a chart over a wall of numbers, but never invent data for it.",
+  inputSchema: {
+    properties: {
+      actions: ACTIONS_SCHEMA,
+      labels: {
+        description: "Category labels — x-axis for bar/line, slice names for donut (max 24)",
+        items: { type: "string" },
+        type: "array"
+      },
+      series: {
+        description: "Data series (max 8; donut exactly 1)",
+        items: SERIES_SCHEMA,
+        type: "array"
+      },
+      title: { description: "Short chart title", type: "string" },
+      type: { enum: [...CHART_TYPES], type: "string" },
+      unitPrefix: {
+        description: 'Prepended to values, e.g. "$"',
+        type: "string"
+      },
+      unitSuffix: {
+        description: 'Appended to values, e.g. "%"',
+        type: "string"
+      }
+    },
+    required: ["type", "title", "labels", "series"],
+    type: "object"
+  },
+  name: "render_chart",
+  parse: parseChartSpec
+};
+var tableCard = {
+  ack: "(table rendered inline — do not repeat its rows as text)",
+  description: "Render a compact data table inline in the chat (max 8 columns × 30 rows). Use for structured comparisons the member will scan — matches side by side, deal terms, task lists with dates. All cells are strings; format numbers yourself.",
+  inputSchema: {
+    properties: {
+      actions: ACTIONS_SCHEMA,
+      columns: {
+        description: "Column headers (max 8)",
+        items: { type: "string" },
+        type: "array"
+      },
+      rows: {
+        description: "Rows of cells, each aligned to columns (max 30)",
+        items: { items: { type: "string" }, type: "array" },
+        type: "array"
+      },
+      title: { description: "Optional table title", type: "string" }
+    },
+    required: ["columns", "rows"],
+    type: "object"
+  },
+  name: "render_table",
+  parse: parseTableSpec
+};
+var statTilesCard = {
+  ack: "(stat tiles rendered inline — do not repeat the numbers as text)",
+  description: "Render a row of headline stat tiles inline in the chat (max 6): a label, a big value, and an optional delta with direction. Use for the 2-4 numbers that ARE the answer — total attributed revenue, pipeline value, credits remaining — instead of burying them in prose.",
+  inputSchema: {
+    properties: {
+      actions: ACTIONS_SCHEMA,
+      tiles: {
+        description: "The tiles (max 6)",
+        items: {
+          properties: {
+            delta: {
+              description: 'Optional change note, e.g. "+12% vs last month"',
+              type: "string"
+            },
+            deltaDirection: { enum: ["up", "down", "flat"], type: "string" },
+            label: { description: "What the number is", type: "string" },
+            value: {
+              description: 'The formatted headline value, e.g. "$42,300"',
+              type: "string"
+            }
+          },
+          required: ["label", "value"],
+          type: "object"
+        },
+        type: "array"
+      }
+    },
+    required: ["tiles"],
+    type: "object"
+  },
+  name: "render_stat_tiles",
+  parse: parseStatTilesSpec
+};
+var BUILTIN_UI_CARDS = [chartCard, tableCard, statTilesCard];
+// src/ai/ui/svg.ts
+var LIGHT_UI_THEME = {
+  grid: "#e4e4e0",
+  palette: [
+    "#2a78d6",
+    "#1baf7a",
+    "#eda100",
+    "#008300",
+    "#4a3aa7",
+    "#e34948",
+    "#e87ba4",
+    "#eb6834"
+  ],
+  surface: "#fcfcfb",
+  textPrimary: "#0b0b0b",
+  textSecondary: "#52514e"
+};
+var DARK_UI_THEME = {
+  grid: "#333331",
+  palette: [
+    "#3987e5",
+    "#199e70",
+    "#c98500",
+    "#008300",
+    "#9085e9",
+    "#e66767",
+    "#d55181",
+    "#d95926"
+  ],
+  surface: "#1a1a19",
+  textPrimary: "#ffffff",
+  textSecondary: "#c3c2b7"
+};
+var WIDTH = 640;
+var HEIGHT = 340;
+var MARGIN = { bottom: 42, left: 56, right: 16, top: 64 };
+var BAR_END_RADIUS = 4;
+var MARK_GAP = 2;
+var LINE_WIDTH = 2;
+var MAX_DIRECT_LABELED_SERIES = 4;
+var TICK_TARGET = 4;
+var FONT = "system-ui, -apple-system, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif";
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+var formatValue = (value, spec) => {
+  const sign = value < 0 ? "-" : "";
+  const abs = Math.abs(value);
+  const compact = abs >= 1e6 ? `${(abs / 1e6).toFixed(1).replace(/\.0$/, "")}M` : abs >= 1e4 ? `${(abs / 1000).toFixed(1).replace(/\.0$/, "")}k` : abs >= 1000 ? abs.toLocaleString("en-US") : `${Number.isInteger(abs) ? abs : abs.toFixed(1)}`;
+  return `${sign}${spec.unitPrefix ?? ""}${compact}${spec.unitSuffix ?? ""}`;
+};
+var niceTicks = (min, max) => {
+  const span = max - min || 1;
+  const rough = span / TICK_TARGET;
+  const power = Math.pow(10, Math.floor(Math.log10(rough)));
+  const candidates = [1, 2, 5, 10].map((step2) => step2 * power);
+  const step = candidates.find((candidate) => candidate >= rough) ?? candidates[candidates.length - 1] ?? rough;
+  const start = Math.floor(min / step) * step;
+  const ticks = [];
+  for (let tick = start;tick <= max + step / 2; tick += step) {
+    ticks.push(Math.abs(tick) < step / 1e6 ? 0 : tick);
+  }
+  return ticks;
+};
+var headerSvg = (spec, frame) => {
+  const { theme } = frame;
+  const parts = [
+    `<text x="${frame.plotLeft}" y="24" fill="${theme.textPrimary}" font-size="15" font-weight="600">${escapeXml(spec.title)}</text>`
+  ];
+  if (spec.series.length > 1) {
+    let x = frame.plotLeft;
+    const swatches = spec.series.map((series, index) => {
+      const color = theme.palette[index % theme.palette.length];
+      const label = escapeXml(series.name);
+      const item = `<rect x="${x}" y="38" width="10" height="10" rx="2" fill="${color}"/><text x="${x + 14}" y="47" fill="${theme.textSecondary}" font-size="11">${label}</text>`;
+      x += 14 + series.name.length * 6 + 18;
+      return item;
+    });
+    parts.push(...swatches);
+  }
+  return parts.join("");
+};
+var gridSvg = (ticks, yFor, spec, frame) => ticks.map((tick) => {
+  const y = yFor(tick);
+  const isZero = tick === 0;
+  return `<line x1="${frame.plotLeft}" y1="${y}" x2="${frame.plotRight}" y2="${y}" stroke="${isZero ? frame.theme.textSecondary : frame.theme.grid}" stroke-width="1"/><text x="${frame.plotLeft - 8}" y="${y + 3.5}" fill="${frame.theme.textSecondary}" font-size="10" text-anchor="end">${escapeXml(formatValue(tick, spec))}</text>`;
+}).join("");
+var xLabelsSvg = (spec, xCenter, frame) => {
+  const every = Math.ceil(spec.labels.length / 12);
+  return spec.labels.map((label, index) => {
+    if (index % every !== 0)
+      return "";
+    const short = label.length > 12 ? `${label.slice(0, 11)}…` : label;
+    return `<text x="${xCenter(index)}" y="${frame.plotBottom + 18}" fill="${frame.theme.textSecondary}" font-size="10" text-anchor="middle">${escapeXml(short)}</text>`;
+  }).join("");
+};
+var barPath = (x, yValue, yBase, width) => {
+  const up = yValue <= yBase;
+  const top = Math.min(yValue, yBase);
+  const bottom = Math.max(yValue, yBase);
+  const radius = Math.min(BAR_END_RADIUS, width / 2, bottom - top);
+  if (radius <= 0)
+    return "";
+  if (up) {
+    return `M${x},${bottom} L${x},${top + radius} Q${x},${top} ${x + radius},${top} L${x + width - radius},${top} Q${x + width},${top} ${x + width},${top + radius} L${x + width},${bottom} Z`;
+  }
+  return `M${x},${top} L${x},${bottom - radius} Q${x},${bottom} ${x + radius},${bottom} L${x + width - radius},${bottom} Q${x + width},${bottom} ${x + width},${bottom - radius} L${x + width},${top} Z`;
+};
+var valueDomain = (spec) => {
+  const all = spec.series.flatMap((series) => series.values);
+  const min = Math.min(0, ...all);
+  const max = Math.max(0, ...all);
+  return max === min ? { max: min + 1, min } : { max, min };
+};
+var cartesianSvg = (spec, frame) => {
+  const { theme } = frame;
+  const domain = valueDomain(spec);
+  const ticks = niceTicks(domain.min, domain.max);
+  const lo = Math.min(domain.min, ticks[0] ?? domain.min);
+  const hi = Math.max(domain.max, ticks[ticks.length - 1] ?? domain.max);
+  const yFor = (value) => frame.plotBottom - (value - lo) / (hi - lo) * (frame.plotBottom - frame.plotTop);
+  const slot = (frame.plotRight - frame.plotLeft) / spec.labels.length;
+  const xCenter = (index) => frame.plotLeft + slot * (index + 0.5);
+  const parts = [gridSvg(ticks, yFor, spec, frame)];
+  if (spec.type === "bar") {
+    const group = Math.min(slot * 0.72, 64);
+    const barWidth = Math.max(2, (group - MARK_GAP * (spec.series.length - 1)) / spec.series.length);
+    const yBase = yFor(Math.max(lo, Math.min(hi, 0)));
+    spec.series.forEach((series, seriesIndex) => {
+      const color = theme.palette[seriesIndex % theme.palette.length];
+      series.values.forEach((value, index) => {
+        const x = xCenter(index) - group / 2 + seriesIndex * (barWidth + MARK_GAP);
+        const tooltip = `${escapeXml(series.name)} · ${escapeXml(spec.labels[index] ?? "")}: ${escapeXml(formatValue(value, spec))}`;
+        parts.push(`<path d="${barPath(x, yFor(value), yBase, barWidth)}" fill="${color}"><title>${tooltip}</title></path>`);
+      });
+    });
+    const [only] = spec.series;
+    if (spec.series.length === 1 && only && spec.labels.length <= 8) {
+      only.values.forEach((value, index) => {
+        const above = value >= 0;
+        parts.push(`<text x="${xCenter(index)}" y="${yFor(value) + (above ? -6 : 14)}" fill="${theme.textSecondary}" font-size="10" text-anchor="middle">${escapeXml(formatValue(value, spec))}</text>`);
+      });
+    }
+  } else {
+    spec.series.forEach((series, seriesIndex) => {
+      const color = theme.palette[seriesIndex % theme.palette.length];
+      const points = series.values.map((value, index) => `${xCenter(index)},${yFor(value)}`);
+      parts.push(`<polyline points="${points.join(" ")}" fill="none" stroke="${color}" stroke-width="${LINE_WIDTH}" stroke-linejoin="round" stroke-linecap="round"/>`);
+      series.values.forEach((value, index) => {
+        const tooltip = `${escapeXml(series.name)} · ${escapeXml(spec.labels[index] ?? "")}: ${escapeXml(formatValue(value, spec))}`;
+        parts.push(`<circle cx="${xCenter(index)}" cy="${yFor(value)}" r="4" fill="${color}" stroke="${theme.surface}" stroke-width="2"><title>${tooltip}</title></circle>`);
+      });
+      const last = series.values[series.values.length - 1];
+      if (spec.series.length <= MAX_DIRECT_LABELED_SERIES && last !== undefined) {
+        parts.push(`<text x="${frame.plotRight + 4}" y="${yFor(last) + 3.5}" fill="${theme.textSecondary}" font-size="10">${escapeXml(series.name)}</text>`);
+      }
+    });
+  }
+  parts.push(xLabelsSvg(spec, xCenter, frame));
+  return parts.join("");
+};
+var donutSvg = (spec, frame) => {
+  const { theme } = frame;
+  const [series] = spec.series;
+  if (!series)
+    return "";
+  const total = series.values.reduce((sum, value) => sum + value, 0);
+  if (total <= 0)
+    return "";
+  const cx = (frame.plotLeft + frame.plotRight) / 2;
+  const cy = (frame.plotTop + frame.plotBottom) / 2 + 4;
+  const radius = Math.min((frame.plotBottom - frame.plotTop) / 2 - 4, (frame.plotRight - frame.plotLeft) / 4);
+  const ring = Math.max(14, radius * 0.34);
+  const mid = radius - ring / 2;
+  const gapAngle = MARK_GAP / mid;
+  const parts = [];
+  let angle = -Math.PI / 2;
+  series.values.forEach((value, index) => {
+    const sweep = value / total * Math.PI * 2;
+    const start = angle + gapAngle / 2;
+    const end = angle + sweep - gapAngle / 2;
+    angle += sweep;
+    if (end <= start)
+      return;
+    const large = end - start > Math.PI ? 1 : 0;
+    const x1 = cx + mid * Math.cos(start);
+    const y1 = cy + mid * Math.sin(start);
+    const x2 = cx + mid * Math.cos(end);
+    const y2 = cy + mid * Math.sin(end);
+    const color = theme.palette[index % theme.palette.length];
+    const share = `${Math.round(value / total * 100)}%`;
+    const tooltip = `${escapeXml(spec.labels[index] ?? "")}: ${escapeXml(formatValue(value, spec))} (${share})`;
+    parts.push(`<path d="M${x1},${y1} A${mid},${mid} 0 ${large} 1 ${x2},${y2}" fill="none" stroke="${color}" stroke-width="${ring}"><title>${tooltip}</title></path>`);
+  });
+  parts.push(`<text x="${cx}" y="${cy + 5}" fill="${theme.textPrimary}" font-size="16" font-weight="600" text-anchor="middle">${escapeXml(formatValue(total, spec))}</text>`);
+  let x = frame.plotLeft;
+  spec.labels.forEach((label, index) => {
+    const color = theme.palette[index % theme.palette.length];
+    parts.push(`<rect x="${x}" y="38" width="10" height="10" rx="2" fill="${color}"/><text x="${x + 14}" y="47" fill="${theme.textSecondary}" font-size="11">${escapeXml(label)}</text>`);
+    x += 14 + label.length * 6 + 18;
+  });
+  return parts.join("");
+};
+var renderChartSvg = (spec, options = {}) => {
+  const base = options.mode === "dark" ? DARK_UI_THEME : LIGHT_UI_THEME;
+  const theme = { ...base, ...options.theme };
+  const width = options.width ?? WIDTH;
+  const height = options.height ?? HEIGHT;
+  const frame = {
+    plotBottom: height - MARGIN.bottom,
+    plotLeft: MARGIN.left,
+    plotRight: width - MARGIN.right - (spec.type === "line" ? 64 : 0),
+    plotTop: MARGIN.top,
+    theme
+  };
+  const body = spec.type === "donut" ? donutSvg(spec, frame) : cartesianSvg(spec, frame);
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeXml(spec.title)}" font-family="${FONT}"><rect width="${width}" height="${height}" fill="${theme.surface}" rx="12"/>${spec.type === "donut" ? headerSvg({ ...spec, series: [] }, frame) : headerSvg(spec, frame)}${body}</svg>`;
+};
+export {
+  tableCard,
+  statTilesCard,
+  renderChartSvg,
+  parseUiActions,
+  parseTableSpec,
+  parseStatTilesSpec,
+  parseChartSpec,
+  createUiCards,
+  chartCard,
+  UI_ACTIONS_MAX,
+  TABLE_MAX_ROWS,
+  TABLE_MAX_COLUMNS,
+  STAT_TILES_MAX,
+  LIGHT_UI_THEME,
+  DARK_UI_THEME,
+  CHART_TYPES,
+  CHART_MAX_SERIES,
+  CHART_MAX_POINTS,
+  BUILTIN_UI_CARDS
+};
+
+//# debugId=361FE26314A51E4B64756E2164756E21
+//# sourceMappingURL=index.js.map