@constela/runtime 2.0.6 → 2.0.7

package/dist/index.js

@@ -376,7 +376,6 @@ function createTypedStateStore(definitions) {
 }
 
 // src/expression/evaluator.ts
-import { CHART_HELPERS } from "@constela/core";
 var SAFE_ARRAY_METHODS = /* @__PURE__ */ new Set([
   "length",
   "at",
@@ -959,8 +958,28 @@ var GLOBAL_FUNCTIONS = {
   // Virtual scroll helpers
   getVisibleRange: (scrollTop, itemHeight, containerHeight, overscan) => getVisibleRange(scrollTop, itemHeight, containerHeight, overscan),
   getTotalHeight: (itemCount, itemHeight) => getTotalHeight(itemCount, itemHeight),
-  // Chart helpers (from @constela/core)
-  ...CHART_HELPERS
+  // Chart helpers - Coordinate calculation
+  normalizeValue: (value, min, max) => normalizeValue(value, min, max),
+  scaleValue: (value, domainMin, domainMax, rangeMin, rangeMax) => scaleValue(value, domainMin, domainMax, rangeMin, rangeMax),
+  getBarDimensions: (data, index, width, height, gap, orientation) => getBarDimensions(data, index, width, height, gap, orientation),
+  // Chart helpers - Path generation
+  getLinePath: (points, curved) => getLinePath(points, curved),
+  getAreaPath: (points, baseline, curved) => getAreaPath(points, baseline, curved),
+  getArcPath: (cx, cy, radius, startAngle, endAngle) => getArcPath(cx, cy, radius, startAngle, endAngle),
+  // Chart helpers - Pie/Donut
+  getPieSlices: (data, valueKey) => getPieSlices(data, valueKey),
+  getDonutSlices: (data, valueKey, innerRadius) => getDonutSlices(data, valueKey, innerRadius),
+  // Chart helpers - Radar
+  getRadarPoints: (data, valueKey, cx, cy, radius, maxValue) => getRadarPoints(data, valueKey, cx, cy, radius, maxValue),
+  getRadarAxes: (labels, cx, cy, radius) => getRadarAxes(labels, cx, cy, radius),
+  // Chart helpers - Utilities
+  getChartBounds: (data, valueKey) => getChartBounds(data, valueKey),
+  getLinePoints: (data, valueKey, width, height, padding) => getLinePoints(data, valueKey, width, height, padding),
+  generateTicks: (min, max, count) => generateTicks(min, max, count),
+  // Chart helpers - Data aggregation
+  binData: (data, valueKey, binCount) => binData(data, valueKey, binCount),
+  aggregateData: (data, groupKey, valueKey, aggregation) => aggregateData(data, groupKey, valueKey, aggregation),
+  downsample: (data, targetCount, method) => downsample(data, targetCount, method)
 };
 function callGlobalFunction(method, args) {
   const fn = GLOBAL_FUNCTIONS[method];
@@ -1293,6 +1312,548 @@ function evaluateBinary(op, left, right, ctx) {
       throw new Error("Unknown binary operator: " + op);
   }
 }
+function normalizeValue(value, min, max) {
+  if (typeof value !== "number" || typeof min !== "number" || typeof max !== "number") {
+    return void 0;
+  }
+  if (max === min) {
+    return 0;
+  }
+  return (value - min) / (max - min);
+}
+function scaleValue(value, domainMin, domainMax, rangeMin, rangeMax) {
+  if (typeof value !== "number" || typeof domainMin !== "number" || typeof domainMax !== "number" || typeof rangeMin !== "number" || typeof rangeMax !== "number") {
+    return void 0;
+  }
+  if (domainMax === domainMin) {
+    return rangeMin;
+  }
+  const normalized = (value - domainMin) / (domainMax - domainMin);
+  return rangeMin + normalized * (rangeMax - rangeMin);
+}
+function getBarDimensions(data, index, width, height, gap, orientation) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return void 0;
+  }
+  if (typeof index !== "number" || index < 0 || index >= data.length) {
+    return void 0;
+  }
+  if (typeof width !== "number" || typeof height !== "number" || typeof gap !== "number") {
+    return void 0;
+  }
+  const isVertical = orientation === "vertical";
+  const barCount = data.length;
+  const values = data.map((d2) => typeof d2 === "number" ? d2 : 0);
+  const maxValue = Math.max(...values);
+  if (isVertical) {
+    const totalGap = gap * (barCount + 1);
+    const barWidth = (width - totalGap) / barCount;
+    const barX = gap + index * (barWidth + gap);
+    const value = values[index] ?? 0;
+    const barHeight = maxValue > 0 ? value / maxValue * height : 0;
+    const barY = height - barHeight;
+    return {
+      x: barX,
+      y: barY,
+      width: barWidth,
+      height: barHeight
+    };
+  } else {
+    const totalGap = gap * barCount;
+    const barHeight = (height - totalGap) / barCount;
+    const barY = gap + index * (barHeight + gap);
+    const value = values[index] ?? 0;
+    const barWidth = maxValue > 0 ? value / maxValue * width : 0;
+    return {
+      x: 0,
+      y: barY,
+      width: barWidth,
+      height: barHeight
+    };
+  }
+}
+function getCurvedPath(points) {
+  if (points.length < 2) {
+    return points.length === 1 ? `M${points[0].x},${points[0].y}` : "";
+  }
+  if (points.length === 2) {
+    return `M${points[0].x},${points[0].y} L${points[1].x},${points[1].y}`;
+  }
+  const pathParts = [`M${points[0].x},${points[0].y}`];
+  for (let i = 0; i < points.length - 1; i++) {
+    const p0 = points[Math.max(0, i - 1)];
+    const p1 = points[i];
+    const p2 = points[i + 1];
+    const p3 = points[Math.min(points.length - 1, i + 2)];
+    const cp1x = p1.x + (p2.x - p0.x) / 6;
+    const cp1y = p1.y + (p2.y - p0.y) / 6;
+    const cp2x = p2.x - (p3.x - p1.x) / 6;
+    const cp2y = p2.y - (p3.y - p1.y) / 6;
+    pathParts.push(`C${cp1x},${cp1y} ${cp2x},${cp2y} ${p2.x},${p2.y}`);
+  }
+  return pathParts.join(" ");
+}
+function getLinePath(points, curved) {
+  if (!Array.isArray(points)) {
+    return void 0;
+  }
+  if (points.length === 0) {
+    return "";
+  }
+  for (const point of points) {
+    if (typeof point !== "object" || point === null || typeof point.x !== "number" || typeof point.y !== "number") {
+      return void 0;
+    }
+  }
+  const validPoints = points;
+  if (validPoints.length === 1) {
+    return `M${validPoints[0].x},${validPoints[0].y}`;
+  }
+  if (curved !== true) {
+    const pathParts = validPoints.map((point, i) => {
+      const command = i === 0 ? "M" : "L";
+      return `${command}${point.x},${point.y}`;
+    });
+    return pathParts.join(" ");
+  }
+  return getCurvedPath(validPoints);
+}
+function getAreaPath(points, baseline, curved) {
+  if (!Array.isArray(points)) {
+    return void 0;
+  }
+  if (typeof baseline !== "number") {
+    return void 0;
+  }
+  if (points.length === 0) {
+    return "";
+  }
+  for (const point of points) {
+    if (typeof point !== "object" || point === null || typeof point.x !== "number" || typeof point.y !== "number") {
+      return void 0;
+    }
+  }
+  const validPoints = points;
+  let upperPath;
+  if (curved === true && validPoints.length > 2) {
+    upperPath = getCurvedPath(validPoints);
+  } else {
+    upperPath = validPoints.map((p2, i) => (i === 0 ? "M" : "L") + `${p2.x},${p2.y}`).join(" ");
+  }
+  const lastPoint = validPoints[validPoints.length - 1];
+  const firstPoint = validPoints[0];
+  return `${upperPath} L${lastPoint.x},${baseline} L${firstPoint.x},${baseline} Z`;
+}
+function getArcPath(cx, cy, radius, startAngle, endAngle) {
+  if (typeof cx !== "number" || typeof cy !== "number" || typeof radius !== "number" || typeof startAngle !== "number" || typeof endAngle !== "number") {
+    return void 0;
+  }
+  if (radius <= 0) {
+    return void 0;
+  }
+  const x1 = cx + radius * Math.cos(startAngle);
+  const y1 = cy + radius * Math.sin(startAngle);
+  const x2 = cx + radius * Math.cos(endAngle);
+  const y2 = cy + radius * Math.sin(endAngle);
+  const angleDiff = endAngle - startAngle;
+  const largeArcFlag = Math.abs(angleDiff) > Math.PI ? 1 : 0;
+  return `M${x1},${y1} A${radius},${radius} 0 ${largeArcFlag},1 ${x2},${y2}`;
+}
+function getPieSlices(data, valueKey) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof valueKey !== "string") {
+    return void 0;
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  const values = data.map((item) => {
+    if (typeof item !== "object" || item === null) return 0;
+    const val = item[valueKey];
+    return typeof val === "number" ? val : 0;
+  });
+  const total = values.reduce((sum, val) => sum + val, 0);
+  const slices = [];
+  let currentAngle = 0;
+  for (let i = 0; i < values.length; i++) {
+    const value = values[i];
+    const percentage = total > 0 ? value / total * 100 : 0;
+    const angleSpan = total > 0 ? value / total * Math.PI * 2 : 0;
+    slices.push({
+      startAngle: currentAngle,
+      endAngle: currentAngle + angleSpan,
+      value,
+      percentage
+    });
+    currentAngle += angleSpan;
+  }
+  return slices;
+}
+function getDonutSlices(data, valueKey, innerRadius) {
+  if (typeof innerRadius !== "number" || innerRadius < 0) {
+    return void 0;
+  }
+  const pieSlices = getPieSlices(data, valueKey);
+  if (pieSlices === void 0) {
+    return void 0;
+  }
+  const outerRadius = 100;
+  return pieSlices.map((slice) => ({
+    ...slice,
+    outerRadius,
+    innerRadius
+  }));
+}
+function getRadarPoints(data, valueKey, cx, cy, radius, maxValue) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof valueKey !== "string") {
+    return void 0;
+  }
+  if (typeof cx !== "number" || typeof cy !== "number" || typeof radius !== "number" || typeof maxValue !== "number") {
+    return void 0;
+  }
+  if (maxValue <= 0) {
+    return void 0;
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  const points = [];
+  const angleStep = Math.PI * 2 / data.length;
+  for (let i = 0; i < data.length; i++) {
+    const item = data[i];
+    const value = typeof item === "object" && item !== null ? item[valueKey] : 0;
+    const numValue = typeof value === "number" ? value : 0;
+    const scaledRadius = numValue / maxValue * radius;
+    const angle = -Math.PI / 2 + i * angleStep;
+    const x2 = cx + scaledRadius * Math.cos(angle);
+    const y2 = cy + scaledRadius * Math.sin(angle);
+    points.push({ x: x2, y: y2 });
+  }
+  return points;
+}
+function getRadarAxes(labels, cx, cy, radius) {
+  if (!Array.isArray(labels)) {
+    return void 0;
+  }
+  if (typeof cx !== "number" || typeof cy !== "number" || typeof radius !== "number") {
+    return void 0;
+  }
+  if (radius < 0) {
+    return void 0;
+  }
+  if (labels.length === 0) {
+    return [];
+  }
+  const axes = [];
+  const angleStep = Math.PI * 2 / labels.length;
+  for (let i = 0; i < labels.length; i++) {
+    const label = String(labels[i]);
+    const angle = -Math.PI / 2 + i * angleStep;
+    const x2 = cx + radius * Math.cos(angle);
+    const y2 = cy + radius * Math.sin(angle);
+    axes.push({
+      x1: cx,
+      y1: cy,
+      x2,
+      y2,
+      label,
+      angle
+    });
+  }
+  return axes;
+}
+function getChartBounds(data, valueKey) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return void 0;
+  }
+  if (typeof valueKey !== "string") {
+    return void 0;
+  }
+  const values = [];
+  for (const item of data) {
+    if (typeof item !== "object" || item === null) {
+      continue;
+    }
+    const val = item[valueKey];
+    if (typeof val === "number") {
+      values.push(val);
+    }
+  }
+  if (values.length === 0) {
+    return void 0;
+  }
+  return {
+    min: Math.min(...values),
+    max: Math.max(...values)
+  };
+}
+function getLinePoints(data, valueKey, width, height, padding) {
+  if (!Array.isArray(data) || data.length === 0) return void 0;
+  if (typeof valueKey !== "string") return void 0;
+  if (typeof width !== "number" || typeof height !== "number") return void 0;
+  if (width <= 0 || height <= 0) return void 0;
+  const pad = typeof padding === "number" ? padding : 40;
+  if (typeof padding !== "undefined" && typeof padding !== "number") return void 0;
+  const bounds = getChartBounds(data, valueKey);
+  if (!bounds) return void 0;
+  const { min, max } = bounds;
+  const chartWidth = width - pad * 2;
+  const chartHeight = height - pad * 2;
+  return data.map((item, idx) => {
+    const value = item[valueKey];
+    if (typeof value !== "number") return { x: 0, y: 0 };
+    const x2 = data.length === 1 ? pad : pad + idx / (data.length - 1) * chartWidth;
+    const y2 = min === max ? pad + chartHeight / 2 : pad + chartHeight - scaleValue(value, min, max, 0, chartHeight);
+    return { x: x2, y: y2 };
+  });
+}
+function generateTicks(min, max, count) {
+  if (typeof min !== "number" || typeof max !== "number" || typeof count !== "number") {
+    return [];
+  }
+  if (count <= 0) {
+    return [];
+  }
+  if (min === max) {
+    return [min];
+  }
+  if (count === 1) {
+    return [min];
+  }
+  if (count === 2) {
+    return [min, max];
+  }
+  const range = max - min;
+  const rawStep = range / (count - 1);
+  const niceStep = getNiceStep(rawStep);
+  const niceMin = Math.floor(min / niceStep) * niceStep;
+  const ticks = [];
+  for (let i = 0; i < count; i++) {
+    const tick = niceMin + i * niceStep;
+    ticks.push(Math.round(tick * 1e10) / 1e10);
+  }
+  return ticks;
+}
+function getNiceStep(rawStep) {
+  const magnitude = Math.pow(10, Math.floor(Math.log10(rawStep)));
+  const normalized = rawStep / magnitude;
+  let niceNormalized;
+  if (normalized <= 1) {
+    niceNormalized = 1;
+  } else if (normalized <= 2) {
+    niceNormalized = 2;
+  } else if (normalized <= 2.5) {
+    niceNormalized = 2.5;
+  } else if (normalized <= 5) {
+    niceNormalized = 5;
+  } else {
+    niceNormalized = 10;
+  }
+  return niceNormalized * magnitude;
+}
+function binData(data, valueKey, binCount) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof valueKey !== "string") {
+    return void 0;
+  }
+  if (typeof binCount !== "number" || binCount <= 0) {
+    return [];
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  const values = [];
+  for (const item of data) {
+    if (typeof item !== "object" || item === null) continue;
+    const val = item[valueKey];
+    if (typeof val === "number") {
+      values.push(val);
+    }
+  }
+  if (values.length === 0) {
+    return [];
+  }
+  const minVal = Math.min(...values);
+  const maxVal = Math.max(...values);
+  const binWidth = maxVal === minVal ? 1 : (maxVal - minVal) / binCount;
+  const bins = [];
+  for (let i = 0; i < binCount; i++) {
+    bins.push({
+      binStart: minVal + i * binWidth,
+      binEnd: minVal + (i + 1) * binWidth,
+      count: 0,
+      values: []
+    });
+  }
+  for (const val of values) {
+    let binIndex = Math.floor((val - minVal) / binWidth);
+    if (binIndex >= binCount) {
+      binIndex = binCount - 1;
+    }
+    bins[binIndex].count++;
+    bins[binIndex].values.push(val);
+  }
+  return bins;
+}
+function aggregateData(data, groupKey, valueKey, aggregation) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof groupKey !== "string" || typeof valueKey !== "string") {
+    return void 0;
+  }
+  const validAggregations = /* @__PURE__ */ new Set(["sum", "avg", "min", "max", "count"]);
+  if (typeof aggregation !== "string" || !validAggregations.has(aggregation)) {
+    return void 0;
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of data) {
+    if (typeof item !== "object" || item === null) continue;
+    const obj = item;
+    const group = String(obj[groupKey] ?? "");
+    const val = obj[valueKey];
+    const numVal = typeof val === "number" ? val : 0;
+    if (!groups.has(group)) {
+      groups.set(group, []);
+    }
+    groups.get(group).push(numVal);
+  }
+  const result = [];
+  for (const [group, values] of groups) {
+    let aggregatedValue;
+    switch (aggregation) {
+      case "sum":
+        aggregatedValue = values.reduce((sum, v2) => sum + v2, 0);
+        break;
+      case "avg":
+        aggregatedValue = values.reduce((sum, v2) => sum + v2, 0) / values.length;
+        break;
+      case "min":
+        aggregatedValue = Math.min(...values);
+        break;
+      case "max":
+        aggregatedValue = Math.max(...values);
+        break;
+      case "count":
+        aggregatedValue = values.length;
+        break;
+      default:
+        aggregatedValue = 0;
+    }
+    result.push({ group, value: aggregatedValue });
+  }
+  return result;
+}
+function downsample(data, targetCount, method) {
+  if (!Array.isArray(data)) {
+    return void 0;
+  }
+  if (typeof targetCount !== "number" || targetCount <= 0) {
+    return void 0;
+  }
+  const validMethods = /* @__PURE__ */ new Set(["uniform", "lttb"]);
+  if (typeof method !== "string" || !validMethods.has(method)) {
+    return void 0;
+  }
+  if (data.length === 0) {
+    return [];
+  }
+  if (targetCount >= data.length) {
+    return data;
+  }
+  if (method === "uniform") {
+    return downsampleUniform(data, targetCount);
+  } else {
+    return downsampleLTTB(data, targetCount);
+  }
+}
+function downsampleUniform(data, targetCount) {
+  if (targetCount === 1) {
+    return [data[0]];
+  }
+  if (targetCount === 2) {
+    return [data[0], data[data.length - 1]];
+  }
+  const result = [];
+  const step = (data.length - 1) / (targetCount - 1);
+  for (let i = 0; i < targetCount; i++) {
+    const index = Math.round(i * step);
+    result.push(data[index]);
+  }
+  return result;
+}
+function downsampleLTTB(data, targetCount) {
+  if (targetCount === 1) {
+    return [data[0]];
+  }
+  if (targetCount === 2) {
+    return [data[0], data[data.length - 1]];
+  }
+  const getXY = (point) => {
+    if (typeof point !== "object" || point === null) {
+      return { x: 0, y: 0 };
+    }
+    const obj = point;
+    const x2 = typeof obj["x"] === "number" ? obj["x"] : typeof obj["timestamp"] === "number" ? obj["timestamp"] : 0;
+    const y2 = typeof obj["y"] === "number" ? obj["y"] : typeof obj["value"] === "number" ? obj["value"] : 0;
+    return { x: x2, y: y2 };
+  };
+  const result = [];
+  result.push(data[0]);
+  const numBuckets = targetCount - 2;
+  const middleData = data.length - 2;
+  const bucketSize = middleData / numBuckets;
+  let prevSelectedIndex = 0;
+  for (let bucketIndex = 0; bucketIndex < numBuckets; bucketIndex++) {
+    const bucketStart = Math.floor(bucketIndex * bucketSize) + 1;
+    const bucketEnd = Math.floor((bucketIndex + 1) * bucketSize) + 1;
+    const nextBucketStart = bucketEnd;
+    const nextBucketEnd = bucketIndex < numBuckets - 1 ? Math.floor((bucketIndex + 2) * bucketSize) + 1 : data.length;
+    let avgX = 0;
+    let avgY = 0;
+    const nextLen = nextBucketEnd - nextBucketStart;
+    if (nextLen > 0) {
+      for (let j2 = nextBucketStart; j2 < nextBucketEnd; j2++) {
+        const point = getXY(data[j2]);
+        avgX += point.x;
+        avgY += point.y;
+      }
+      avgX /= nextLen;
+      avgY /= nextLen;
+    } else {
+      const lastPoint = getXY(data[data.length - 1]);
+      avgX = lastPoint.x;
+      avgY = lastPoint.y;
+    }
+    const pointA = getXY(data[prevSelectedIndex]);
+    let maxArea = -1;
+    let maxAreaIndex = bucketStart;
+    for (let j2 = bucketStart; j2 < bucketEnd; j2++) {
+      const pointB = getXY(data[j2]);
+      const area = Math.abs(
+        pointA.x * (pointB.y - avgY) + pointB.x * (avgY - pointA.y) + avgX * (pointA.y - pointB.y)
+      );
+      if (area > maxArea) {
+        maxArea = area;
+        maxAreaIndex = j2;
+      }
+    }
+    result.push(data[maxAreaIndex]);
+    prevSelectedIndex = maxAreaIndex;
+  }
+  result.push(data[data.length - 1]);
+  return result;
+}
 function evaluateStyle(expr, ctx) {
   const preset = ctx.styles?.[expr.name];
   if (!preset) return void 0;
@@ -15007,13 +15568,17 @@ function renderPortal(node, ctx) {
 }
 function createLocalStateStore(stateDefs, ctx) {
   const signals = {};
+  const evaluatedValues = {};
   for (const [name, def] of Object.entries(stateDefs)) {
     const initial = def.initial;
     let initialValue;
     if (initial && typeof initial === "object" && "expr" in initial) {
       const evalCtx = {
         state: ctx.state,
-        locals: ctx.locals
+        locals: {
+          ...ctx.locals,
+          ...evaluatedValues
+        }
       };
       if (ctx.route) evalCtx.route = ctx.route;
       if (ctx.imports) evalCtx.imports = ctx.imports;
@@ -15022,6 +15587,7 @@ function createLocalStateStore(stateDefs, ctx) {
       initialValue = initial;
     }
     signals[name] = createSignal(initialValue);
+    evaluatedValues[name] = initialValue;
   }
   return {
     get(name) {
@@ -15352,13 +15918,17 @@ function createReactiveLocals2(baseLocals, itemSignal, indexSignal, itemName, in
 }
 function createLocalStateStore2(stateDefs, ctx) {
   const signals = {};
+  const evaluatedValues = {};
   for (const [name, def] of Object.entries(stateDefs)) {
     const initial = def.initial;
     let initialValue;
     if (initial && typeof initial === "object" && "expr" in initial) {
       const evalCtx = {
         state: ctx.state,
-        locals: ctx.locals
+        locals: {
+          ...ctx.locals,
+          ...evaluatedValues
+        }
       };
       if (ctx.route) evalCtx.route = ctx.route;
       if (ctx.imports) evalCtx.imports = ctx.imports;
@@ -15367,6 +15937,7 @@ function createLocalStateStore2(stateDefs, ctx) {
       initialValue = initial;
     }
     signals[name] = createSignal(initialValue);
+    evaluatedValues[name] = initialValue;
   }
   return {
     get(name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/runtime",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Runtime DOM renderer for Constela UI framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,8 +18,8 @@
     "dompurify": "^3.3.1",
     "marked": "^17.0.1",
     "shiki": "^3.20.0",
-    "@constela/core": "0.18.3",
-    "@constela/compiler": "0.15.9"
+    "@constela/compiler": "0.15.10",
+    "@constela/core": "0.18.4"
   },
   "devDependencies": {
     "@types/dompurify": "^3.2.0",
@@ -29,10 +29,10 @@
     "tsup": "^8.0.0",
     "typescript": "^5.3.0",
     "vitest": "^2.0.0",
-    "@constela/server": "14.0.4"
+    "@constela/server": "14.0.5"
   },
   "peerDependencies": {
-    "@constela/ai": "3.0.3"
+    "@constela/ai": "3.0.4"
   },
   "peerDependenciesMeta": {
     "@constela/ai": {