@constela/runtime 5.0.6 → 6.0.0

package/dist/index.d.ts

@@ -108,16 +108,10 @@ declare function createTypedStateStore<T extends Record<string, unknown>>(defini
 }): TypedStateStore<T>;
 
 /**
- * Expression Evaluator - Evaluates compiled expressions
+ * Expression Evaluator - CSR wrapper around unified @constela/core evaluate
  *
- * Supports:
- * - Literal values (lit)
- * - State reads (state)
- * - Variable reads (var)
- * - Binary operations (bin)
- * - Not operation (not)
- * - Conditional expressions (cond)
- * - Property access (get)
+ * Delegates all expression evaluation to the core module,
+ * providing a CSR-specific EnvironmentAdapter for DOM refs, validity, and globals.
  */
 
 /**
@@ -155,6 +149,10 @@ interface StyleExprInput {
 /**
  * Evaluates a style expression to produce CSS class names
  *
+ * CSR wrapper: delegates to core evaluateStyle, converting '' to undefined
+ * for backward compatibility (core returns '' when preset not found,
+ * CSR returns undefined).
+ *
  * @param expr - The style expression to evaluate
  * @param ctx - The evaluation context containing styles presets
  * @returns The computed CSS class string, or undefined if preset not found

package/dist/index.js

@@ -376,504 +376,55 @@ function createTypedStateStore(definitions) {
 }
 
 // src/expression/evaluator.ts
-import { callGlobalFunction, GLOBAL_FUNCTIONS } from "@constela/core";
-var SAFE_ARRAY_METHODS = /* @__PURE__ */ new Set([
-  "length",
-  "at",
-  "includes",
-  "slice",
-  "indexOf",
-  "join",
-  "filter",
-  "map",
-  "find",
-  "findIndex",
-  "some",
-  "every"
-]);
-var SAFE_STRING_METHODS = /* @__PURE__ */ new Set([
-  "length",
-  "charAt",
-  "substring",
-  "slice",
-  "split",
-  "trim",
-  "toUpperCase",
-  "toLowerCase",
-  "replace",
-  "includes",
-  "startsWith",
-  "endsWith",
-  "indexOf"
-]);
-var SAFE_MATH_METHODS = /* @__PURE__ */ new Set([
-  "min",
-  "max",
-  "round",
-  "floor",
-  "ceil",
-  "abs",
-  "sqrt",
-  "pow",
-  "random",
-  "sin",
-  "cos",
-  "tan"
-]);
-var SAFE_DATE_STATIC_METHODS = /* @__PURE__ */ new Set([
-  "now",
-  "parse"
-]);
-var SAFE_DATE_INSTANCE_METHODS = /* @__PURE__ */ new Set([
-  "toISOString",
-  "toDateString",
-  "toTimeString",
-  "getTime",
-  "getFullYear",
-  "getMonth",
-  "getDate",
-  "getHours",
-  "getMinutes",
-  "getSeconds",
-  "getMilliseconds"
-]);
-function createLambdaFunction(lambda, ctx) {
-  return (item, index) => {
-    const lambdaLocals = {
-      ...ctx.locals,
-      [lambda.param]: item
-    };
-    if (lambda.index !== void 0) {
-      lambdaLocals[lambda.index] = index;
-    }
-    return evaluate(lambda.body, { ...ctx, locals: lambdaLocals });
-  };
-}
-function callArrayMethod(target, method, args, ctx, rawArgs) {
-  if (!SAFE_ARRAY_METHODS.has(method)) {
-    return void 0;
-  }
-  switch (method) {
-    case "length":
-      return target.length;
-    case "at": {
-      const index = typeof args[0] === "number" ? args[0] : 0;
-      return target.at(index);
-    }
-    case "includes": {
-      const searchElement = args[0];
-      const fromIndex = typeof args[1] === "number" ? args[1] : void 0;
-      return target.includes(searchElement, fromIndex);
-    }
-    case "slice": {
-      const start = typeof args[0] === "number" ? args[0] : void 0;
-      const end = typeof args[1] === "number" ? args[1] : void 0;
-      return target.slice(start, end);
-    }
-    case "indexOf": {
-      const searchElement = args[0];
-      const fromIndex = typeof args[1] === "number" ? args[1] : void 0;
-      return target.indexOf(searchElement, fromIndex);
-    }
-    case "join": {
-      const separator = typeof args[0] === "string" ? args[0] : ",";
-      return target.join(separator);
-    }
-    case "filter": {
-      const lambdaExpr = rawArgs?.[0];
-      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
-      const fn = createLambdaFunction(lambdaExpr, ctx);
-      return target.filter((item, index) => !!fn(item, index));
-    }
-    case "map": {
-      const lambdaExpr = rawArgs?.[0];
-      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
-      const fn = createLambdaFunction(lambdaExpr, ctx);
-      return target.map((item, index) => fn(item, index));
-    }
-    case "find": {
-      const lambdaExpr = rawArgs?.[0];
-      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
-      const fn = createLambdaFunction(lambdaExpr, ctx);
-      return target.find((item, index) => !!fn(item, index));
-    }
-    case "findIndex": {
-      const lambdaExpr = rawArgs?.[0];
-      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
-      const fn = createLambdaFunction(lambdaExpr, ctx);
-      return target.findIndex((item, index) => !!fn(item, index));
-    }
-    case "some": {
-      const lambdaExpr = rawArgs?.[0];
-      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
-      const fn = createLambdaFunction(lambdaExpr, ctx);
-      return target.some((item, index) => !!fn(item, index));
-    }
-    case "every": {
-      const lambdaExpr = rawArgs?.[0];
-      if (!lambdaExpr || lambdaExpr.expr !== "lambda") return void 0;
-      const fn = createLambdaFunction(lambdaExpr, ctx);
-      return target.every((item, index) => !!fn(item, index));
-    }
-    default:
-      return void 0;
-  }
-}
-function callStringMethod(target, method, args) {
-  if (!SAFE_STRING_METHODS.has(method)) {
-    return void 0;
-  }
-  switch (method) {
-    case "length":
-      return target.length;
-    case "charAt": {
-      const index = typeof args[0] === "number" ? args[0] : 0;
-      return target.charAt(index);
-    }
-    case "substring": {
-      const start = typeof args[0] === "number" ? args[0] : 0;
-      const end = typeof args[1] === "number" ? args[1] : void 0;
-      return target.substring(start, end);
-    }
-    case "slice": {
-      const start = typeof args[0] === "number" ? args[0] : void 0;
-      const end = typeof args[1] === "number" ? args[1] : void 0;
-      return target.slice(start, end);
-    }
-    case "split": {
-      const separator = typeof args[0] === "string" ? args[0] : "";
-      return target.split(separator);
-    }
-    case "trim":
-      return target.trim();
-    case "toUpperCase":
-      return target.toUpperCase();
-    case "toLowerCase":
-      return target.toLowerCase();
-    case "replace": {
-      const search = typeof args[0] === "string" ? args[0] : "";
-      const replace = typeof args[1] === "string" ? args[1] : "";
-      return target.replace(search, replace);
-    }
-    case "includes": {
-      const search = typeof args[0] === "string" ? args[0] : "";
-      const position = typeof args[1] === "number" ? args[1] : void 0;
-      return target.includes(search, position);
-    }
-    case "startsWith": {
-      const search = typeof args[0] === "string" ? args[0] : "";
-      const position = typeof args[1] === "number" ? args[1] : void 0;
-      return target.startsWith(search, position);
-    }
-    case "endsWith": {
-      const search = typeof args[0] === "string" ? args[0] : "";
-      const length = typeof args[1] === "number" ? args[1] : void 0;
-      return target.endsWith(search, length);
-    }
-    case "indexOf": {
-      const search = typeof args[0] === "string" ? args[0] : "";
-      const position = typeof args[1] === "number" ? args[1] : void 0;
-      return target.indexOf(search, position);
-    }
-    default:
-      return void 0;
-  }
-}
-function callMathMethod(method, args) {
-  if (!SAFE_MATH_METHODS.has(method)) {
-    return void 0;
-  }
-  const numbers = args.filter((a) => typeof a === "number");
-  switch (method) {
-    case "min":
-      return numbers.length > 0 ? Math.min(...numbers) : void 0;
-    case "max":
-      return numbers.length > 0 ? Math.max(...numbers) : void 0;
-    case "round": {
-      const num = numbers[0];
-      return num !== void 0 ? Math.round(num) : void 0;
-    }
-    case "floor": {
-      const num = numbers[0];
-      return num !== void 0 ? Math.floor(num) : void 0;
-    }
-    case "ceil": {
-      const num = numbers[0];
-      return num !== void 0 ? Math.ceil(num) : void 0;
-    }
-    case "abs": {
-      const num = numbers[0];
-      return num !== void 0 ? Math.abs(num) : void 0;
-    }
-    case "sqrt": {
-      const num = numbers[0];
-      return num !== void 0 ? Math.sqrt(num) : void 0;
-    }
-    case "pow": {
-      const base = numbers[0];
-      const exponent = numbers[1];
-      return base !== void 0 && exponent !== void 0 ? Math.pow(base, exponent) : void 0;
-    }
-    case "random":
-      return Math.random();
-    case "sin": {
-      const num = numbers[0];
-      return num !== void 0 ? Math.sin(num) : void 0;
-    }
-    case "cos": {
-      const num = numbers[0];
-      return num !== void 0 ? Math.cos(num) : void 0;
-    }
-    case "tan": {
-      const num = numbers[0];
-      return num !== void 0 ? Math.tan(num) : void 0;
-    }
-    default:
-      return void 0;
-  }
-}
-function callDateStaticMethod(method, args) {
-  if (!SAFE_DATE_STATIC_METHODS.has(method)) {
-    return void 0;
-  }
-  switch (method) {
-    case "now":
-      return Date.now();
-    case "parse": {
-      const dateString = args[0];
-      return typeof dateString === "string" ? Date.parse(dateString) : void 0;
-    }
-    default:
-      return void 0;
-  }
-}
-function callDateInstanceMethod(target, method) {
-  if (!SAFE_DATE_INSTANCE_METHODS.has(method)) {
-    return void 0;
-  }
-  switch (method) {
-    case "toISOString":
-      return target.toISOString();
-    case "toDateString":
-      return target.toDateString();
-    case "toTimeString":
-      return target.toTimeString();
-    case "getTime":
-      return target.getTime();
-    case "getFullYear":
-      return target.getFullYear();
-    case "getMonth":
-      return target.getMonth();
-    case "getDate":
-      return target.getDate();
-    case "getHours":
-      return target.getHours();
-    case "getMinutes":
-      return target.getMinutes();
-    case "getSeconds":
-      return target.getSeconds();
-    case "getMilliseconds":
-      return target.getMilliseconds();
-    default:
-      return void 0;
-  }
-}
-function evaluate(expr, ctx) {
-  switch (expr.expr) {
-    case "lit":
-      return expr.value;
-    case "state": {
-      const stateValue = ctx.state.get(expr.name);
-      if (expr.path && stateValue != null) {
-        return getNestedValue(stateValue, expr.path);
-      }
-      return stateValue;
-    }
-    case "local":
-      return ctx.locals[expr.name];
-    case "var": {
-      let varName = expr.name;
-      let pathParts = [];
-      if (varName.includes(".")) {
-        const parts = varName.split(".");
-        varName = parts[0];
-        pathParts = parts.slice(1);
-      }
-      if (expr.path) {
-        pathParts = pathParts.concat(expr.path.split("."));
-      }
-      const forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-      for (const part of pathParts) {
-        if (forbiddenKeys.has(part)) {
-          return void 0;
-        }
-      }
-      let value = ctx.locals[varName];
-      if (value === void 0) {
-        const safeGlobals = {
-          JSON,
-          Math,
-          Date,
-          Object,
-          Array,
-          String,
-          Number,
-          Boolean,
-          console,
-          ...GLOBAL_FUNCTIONS
-        };
-        value = safeGlobals[varName];
-      }
-      for (const part of pathParts) {
-        if (value == null) break;
-        value = value[part];
-      }
-      if (typeof value === "function" && pathParts.length > 0) {
-        let parent = ctx.locals[varName];
-        if (parent === void 0) {
-          const safeGlobals = { JSON, Math, Date, Object, Array, String, Number, Boolean, console, ...GLOBAL_FUNCTIONS };
-          parent = safeGlobals[varName];
-        }
-        for (let i = 0; i < pathParts.length - 1; i++) {
-          if (parent == null) break;
-          parent = parent[pathParts[i]];
-        }
-        if (parent != null) {
-          return value.bind(parent);
-        }
-      }
-      return value;
-    }
-    case "bin":
-      return evaluateBinary(expr.op, expr.left, expr.right, ctx);
-    case "not":
-      return !evaluate(expr.operand, ctx);
-    case "cond":
-      return evaluate(expr.if, ctx) ? evaluate(expr.then, ctx) : evaluate(expr.else, ctx);
-    case "get": {
-      const baseValue = evaluate(expr.base, ctx);
-      if (baseValue == null) return void 0;
-      const pathParts = expr.path.split(".");
-      const forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-      let value = baseValue;
-      for (const part of pathParts) {
-        if (forbiddenKeys.has(part)) return void 0;
-        if (value == null) return void 0;
-        value = value[part];
-      }
-      return value;
-    }
-    case "route": {
-      const source = expr.source ?? "param";
-      const routeCtx = ctx.route;
-      if (!routeCtx) return "";
-      switch (source) {
-        case "param":
-          return routeCtx.params[expr.name] ?? "";
-        case "query":
-          return routeCtx.query[expr.name] ?? "";
-        case "path":
-          return routeCtx.path;
-      }
-    }
-    case "import": {
-      const importData = ctx.imports?.[expr.name];
-      if (importData === void 0) return void 0;
-      if (expr.path) {
-        return getNestedValue(importData, expr.path);
-      }
-      return importData;
-    }
-    case "ref":
-      return ctx.refs?.[expr.name] ?? null;
-    case "index": {
-      const base = evaluate(expr.base, ctx);
-      const key2 = evaluate(expr.key, ctx);
-      if (base == null || key2 == null) return void 0;
-      const forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-      if (typeof key2 === "string" && forbiddenKeys.has(key2)) return void 0;
-      return base[key2];
-    }
-    case "data": {
-      const dataValue = ctx.imports?.[expr.name];
-      if (dataValue === void 0) return void 0;
-      if (expr.path) {
-        return getNestedValue(dataValue, expr.path);
-      }
-      return dataValue;
-    }
-    case "param": {
-      return void 0;
-    }
-    case "style":
-      return evaluateStyle(expr, ctx);
-    case "concat": {
-      return expr.items.map((item) => {
-        const val = evaluate(item, ctx);
-        return val == null ? "" : String(val);
-      }).join("");
-    }
-    case "validity": {
-      const element2 = ctx.refs?.[expr.ref];
+import { evaluate as coreEvaluate, evaluateStyle as coreEvaluateStyle, GLOBAL_FUNCTIONS, FORBIDDEN_KEYS } from "@constela/core";
+function createCSRAdapter(refs) {
+  return {
+    resolveRef: (name) => refs?.[name] ?? null,
+    resolveValidity(ref, property) {
+      const element2 = refs?.[ref];
       if (!element2) return null;
       const formElement = element2;
       if (!formElement.validity) return null;
       const validity = formElement.validity;
-      const property = expr.property || "valid";
-      if (property === "message") {
+      const prop = property || "valid";
+      if (prop === "message") {
         return formElement.validationMessage || "";
       }
-      return validity[property] ?? null;
-    }
-    case "call": {
-      const callExpr = expr;
-      const target = callExpr.target != null ? evaluate(callExpr.target, ctx) : null;
-      const args = callExpr.args?.map((arg) => {
-        if (arg.expr === "lambda") return arg;
-        return evaluate(arg, ctx);
-      }) ?? [];
-      if (target === null) {
-        return callGlobalFunction(callExpr.method, args);
-      }
-      if (Array.isArray(target)) {
-        return callArrayMethod(target, callExpr.method, args, ctx, callExpr.args);
-      }
-      if (typeof target === "string") {
-        return callStringMethod(target, callExpr.method, args);
-      }
-      if (target === Math) {
-        return callMathMethod(callExpr.method, args);
-      }
-      if (target === Date) {
-        return callDateStaticMethod(callExpr.method, args);
-      }
-      if (target instanceof Date) {
-        return callDateInstanceMethod(target, callExpr.method);
-      }
-      if (typeof target === "function" && callExpr.method === "call") {
-        return target(...args);
-      }
-      return void 0;
-    }
-    case "lambda":
-      return void 0;
-    case "array": {
-      const arrayExpr = expr;
-      return arrayExpr.elements.map((elem) => evaluate(elem, ctx));
-    }
-    case "obj": {
-      const objExpr = expr;
-      const result = {};
-      for (const [key2, value] of Object.entries(objExpr.props)) {
-        result[key2] = evaluate(value, ctx);
-      }
-      return result;
-    }
-    default: {
-      const _exhaustiveCheck = expr;
-      throw new Error(`Unknown expression type: ${JSON.stringify(_exhaustiveCheck)}`);
-    }
-  }
+      return validity[prop] ?? null;
+    },
+    resolveGlobal(name) {
+      const safeGlobals = {
+        JSON,
+        Math,
+        Date,
+        Object,
+        Array,
+        String,
+        Number,
+        Boolean,
+        console,
+        ...GLOBAL_FUNCTIONS
+      };
+      return safeGlobals[name];
+    },
+    bindFunction: (fn, parent) => fn.bind(parent),
+    callFunction: (fn, args) => fn(...args)
+  };
+}
+function toCoreContext(ctx) {
+  const core2 = {
+    state: ctx.state,
+    // StateStore has get(), satisfies StateReader
+    locals: ctx.locals,
+    env: createCSRAdapter(ctx.refs)
+  };
+  if (ctx.route !== void 0) core2.route = ctx.route;
+  if (ctx.imports !== void 0) core2.imports = ctx.imports;
+  if (ctx.styles !== void 0) core2.styles = ctx.styles;
+  return core2;
+}
+function evaluate(expr, ctx) {
+  return coreEvaluate(expr, toCoreContext(ctx));
 }
 function isExpression(value) {
   return typeof value === "object" && value !== null && Object.prototype.hasOwnProperty.call(value, "expr") && typeof value.expr === "string";
@@ -883,10 +434,9 @@ function evaluatePayload(payload, ctx) {
     return evaluate(payload, ctx);
   }
   if (typeof payload === "object" && payload !== null) {
-    const forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
     const result = {};
     for (const [key2, value] of Object.entries(payload)) {
-      if (forbiddenKeys.has(key2)) continue;
+      if (FORBIDDEN_KEYS.has(key2)) continue;
       if (isExpression(value)) {
         result[key2] = evaluate(value, ctx);
       } else {
@@ -897,133 +447,10 @@ function evaluatePayload(payload, ctx) {
   }
   return payload;
 }
-function getNestedValue(obj, path) {
-  const forbiddenKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-  const parts = path.split(".");
-  let value = obj;
-  let parent = null;
-  for (const part of parts) {
-    if (forbiddenKeys.has(part)) {
-      return void 0;
-    }
-    if (value == null) {
-      return void 0;
-    }
-    parent = value;
-    if (Array.isArray(value)) {
-      const index = Number(part);
-      if (Number.isInteger(index) && index >= 0) {
-        value = value[index];
-      } else {
-        value = value[part];
-      }
-    } else if (typeof value === "object") {
-      value = value[part];
-    } else {
-      return void 0;
-    }
-  }
-  if (typeof value === "function" && parent != null) {
-    return value.bind(parent);
-  }
-  return value;
-}
-function evaluateBinary(op, left, right, ctx) {
-  if (op === "&&") {
-    const leftVal2 = evaluate(left, ctx);
-    if (!leftVal2) return leftVal2;
-    return evaluate(right, ctx);
-  }
-  if (op === "||") {
-    const leftVal2 = evaluate(left, ctx);
-    if (leftVal2) return leftVal2;
-    return evaluate(right, ctx);
-  }
-  const leftVal = evaluate(left, ctx);
-  const rightVal = evaluate(right, ctx);
-  switch (op) {
-    // Arithmetic
-    case "+":
-      if (typeof leftVal === "number" && typeof rightVal === "number") {
-        return leftVal + rightVal;
-      }
-      return String(leftVal) + String(rightVal);
-    case "-":
-      return (typeof leftVal === "number" ? leftVal : 0) - (typeof rightVal === "number" ? rightVal : 0);
-    case "*":
-      return (typeof leftVal === "number" ? leftVal : 0) * (typeof rightVal === "number" ? rightVal : 0);
-    case "/": {
-      const dividend = typeof leftVal === "number" ? leftVal : 0;
-      const divisor = typeof rightVal === "number" ? rightVal : 0;
-      if (divisor === 0) {
-        return dividend === 0 ? NaN : dividend > 0 ? Infinity : -Infinity;
-      }
-      return dividend / divisor;
-    }
-    case "%": {
-      const dividend = typeof leftVal === "number" ? leftVal : 0;
-      const divisor = typeof rightVal === "number" ? rightVal : 0;
-      if (divisor === 0) return NaN;
-      return dividend % divisor;
-    }
-    // Comparison (using strict equality)
-    case "==":
-      return leftVal === rightVal;
-    case "!=":
-      return leftVal !== rightVal;
-    case "<":
-      if (typeof leftVal === "number" && typeof rightVal === "number") {
-        return leftVal < rightVal;
-      }
-      return String(leftVal) < String(rightVal);
-    case "<=":
-      if (typeof leftVal === "number" && typeof rightVal === "number") {
-        return leftVal <= rightVal;
-      }
-      return String(leftVal) <= String(rightVal);
-    case ">":
-      if (typeof leftVal === "number" && typeof rightVal === "number") {
-        return leftVal > rightVal;
-      }
-      return String(leftVal) > String(rightVal);
-    case ">=":
-      if (typeof leftVal === "number" && typeof rightVal === "number") {
-        return leftVal >= rightVal;
-      }
-      return String(leftVal) >= String(rightVal);
-    default:
-      throw new Error("Unknown binary operator: " + op);
-  }
-}
 function evaluateStyle(expr, ctx) {
   const preset = ctx.styles?.[expr.name];
   if (!preset) return void 0;
-  let classes = preset.base;
-  if (preset.variants) {
-    for (const variantKey of Object.keys(preset.variants)) {
-      let variantValueStr = null;
-      if (expr.variants?.[variantKey]) {
-        let variantValue;
-        try {
-          variantValue = evaluate(expr.variants[variantKey], ctx);
-        } catch {
-          continue;
-        }
-        if (variantValue != null) {
-          variantValueStr = String(variantValue);
-        }
-      } else if (preset.defaultVariants?.[variantKey] !== void 0) {
-        variantValueStr = preset.defaultVariants[variantKey];
-      }
-      if (variantValueStr !== null) {
-        const variantClasses = preset.variants[variantKey]?.[variantValueStr];
-        if (variantClasses) {
-          classes += " " + variantClasses;
-        }
-      }
-    }
-  }
-  return classes.trim();
+  return coreEvaluateStyle(expr, toCoreContext(ctx));
 }
 
 // src/connection/sse.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/runtime",
-  "version": "5.0.6",
+  "version": "6.0.0",
   "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/compiler": "0.15.20",
-    "@constela/core": "0.21.4"
+    "@constela/compiler": "0.15.21",
+    "@constela/core": "0.22.0"
   },
   "devDependencies": {
     "@types/dompurify": "^3.2.0",
@@ -29,10 +29,10 @@
     "tsup": "^8.0.0",
     "typescript": "^5.3.0",
     "vitest": "^2.0.0",
-    "@constela/server": "17.0.1"
+    "@constela/server": "18.0.0"
   },
   "peerDependencies": {
-    "@constela/ai": "6.0.4"
+    "@constela/ai": "7.0.0"
   },
   "peerDependenciesMeta": {
     "@constela/ai": {