@constela/core 0.3.1 → 0.3.2

package/dist/index.d.ts

@@ -479,7 +479,7 @@ declare function createCondElseRequiredError(path?: string): ConstelaError;
  * AST Validator for Constela
  *
  * This module provides validation for Constela AST structures using
- * JSON Schema validation (AJV) and semantic validation.
+ * custom validation and semantic validation.
  */
 
 interface ValidationSuccess {
@@ -503,6 +503,7 @@ declare function validateAst(input: unknown): ValidationResult;
  * JSON Schema for Constela AST
  *
  * This module defines the JSON Schema for validating Constela AST structures.
+ * The schema is kept for documentation and external tooling purposes.
  */
 declare const astSchema: {
     readonly $schema: "http://json-schema.org/draft-07/schema#";

package/dist/index.js

@@ -324,595 +324,193 @@ function createCondElseRequiredError(path) {
 }
 
 // src/schema/validator.ts
-import Ajv from "ajv";
-
-// src/schema/ast.schema.ts
-var astSchema = {
-  $schema: "http://json-schema.org/draft-07/schema#",
-  $id: "https://constela.dev/schemas/ast.json",
-  title: "Constela AST",
-  description: "Schema for Constela UI framework AST",
-  type: "object",
-  required: ["version", "state", "actions", "view"],
-  additionalProperties: false,
-  properties: {
-    version: {
-      type: "string",
-      const: "1.0"
-    },
-    state: {
-      type: "object",
-      additionalProperties: {
-        $ref: "#/$defs/StateField"
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var VALID_VIEW_KINDS = ["element", "text", "if", "each", "component", "slot"];
+var VALID_EXPR_TYPES = ["lit", "state", "var", "bin", "not", "param"];
+var VALID_PARAM_TYPES = ["string", "number", "boolean", "json"];
+var VALID_ACTION_TYPES = ["set", "update", "fetch"];
+var VALID_STATE_TYPES = ["number", "string", "list", "boolean", "object"];
+var VALID_BIN_OPS = BINARY_OPERATORS;
+var VALID_UPDATE_OPS = UPDATE_OPERATIONS;
+var VALID_HTTP_METHODS = HTTP_METHODS;
+function validateViewNode(node, path) {
+  if (!isObject2(node)) {
+    return { path, message: "must be an object" };
+  }
+  const kind = node["kind"];
+  if (typeof kind !== "string") {
+    return { path: path + "/kind", message: "kind is required" };
+  }
+  if (!VALID_VIEW_KINDS.includes(kind)) {
+    return { path: path + "/kind", message: "must be one of: element, text, if, each, component, slot" };
+  }
+  switch (kind) {
+    case "element":
+      if (typeof node["tag"] !== "string") {
+        return { path: path + "/tag", message: "tag is required" };
       }
-    },
-    actions: {
-      type: "array",
-      items: {
-        $ref: "#/$defs/ActionDefinition"
+      if (node["props"] !== void 0 && isObject2(node["props"])) {
+        for (const [propName, propValue] of Object.entries(node["props"])) {
+          if (isObject2(propValue) && "event" in propValue) {
+          } else {
+            const error = validateExpression(propValue, path + "/props/" + propName);
+            if (error) return error;
+          }
+        }
       }
-    },
-    view: {
-      $ref: "#/$defs/ViewNode"
-    },
-    components: {
-      type: "object",
-      additionalProperties: { $ref: "#/$defs/ComponentDef" }
-    }
-  },
-  $defs: {
-    // ==================== Expressions ====================
-    Expression: {
-      oneOf: [
-        { $ref: "#/$defs/LitExpr" },
-        { $ref: "#/$defs/StateExpr" },
-        { $ref: "#/$defs/VarExpr" },
-        { $ref: "#/$defs/BinExpr" },
-        { $ref: "#/$defs/NotExpr" },
-        { $ref: "#/$defs/ParamExpr" },
-        { $ref: "#/$defs/CondExpr" },
-        { $ref: "#/$defs/GetExpr" }
-      ]
-    },
-    LitExpr: {
-      type: "object",
-      required: ["expr", "value"],
-      additionalProperties: false,
-      properties: {
-        expr: { type: "string", const: "lit" },
-        value: {
-          oneOf: [
-            { type: "string" },
-            { type: "number" },
-            { type: "boolean" },
-            { type: "null" },
-            { type: "array" }
-          ]
+      if (Array.isArray(node["children"])) {
+        for (let i = 0; i < node["children"].length; i++) {
+          const error = validateViewNode(node["children"][i], path + "/children/" + i);
+          if (error) return error;
         }
       }
-    },
-    StateExpr: {
-      type: "object",
-      required: ["expr", "name"],
-      additionalProperties: false,
-      properties: {
-        expr: { type: "string", const: "state" },
-        name: { type: "string" }
+      break;
+    case "text":
+      if (!("value" in node)) {
+        return { path: path + "/value", message: "value is required" };
       }
-    },
-    VarExpr: {
-      type: "object",
-      required: ["expr", "name"],
-      additionalProperties: false,
-      properties: {
-        expr: { type: "string", const: "var" },
-        name: { type: "string" },
-        path: { type: "string" }
+      return validateExpression(node["value"], path + "/value");
+    case "if":
+      if (!("condition" in node)) {
+        return { path: path + "/condition", message: "condition is required" };
       }
-    },
-    BinExpr: {
-      type: "object",
-      required: ["expr", "op", "left", "right"],
-      additionalProperties: false,
-      properties: {
-        expr: { type: "string", const: "bin" },
-        op: {
-          type: "string",
-          enum: ["+", "-", "*", "/", "==", "!=", "<", "<=", ">", ">=", "&&", "||"]
-        },
-        left: { $ref: "#/$defs/Expression" },
-        right: { $ref: "#/$defs/Expression" }
+      if (!("then" in node)) {
+        return { path: path + "/then", message: "then is required" };
       }
-    },
-    NotExpr: {
-      type: "object",
-      required: ["expr", "operand"],
-      additionalProperties: false,
-      properties: {
-        expr: { type: "string", const: "not" },
-        operand: { $ref: "#/$defs/Expression" }
+      {
+        const condError = validateExpression(node["condition"], path + "/condition");
+        if (condError) return condError;
+        const thenError = validateViewNode(node["then"], path + "/then");
+        if (thenError) return thenError;
+        if ("else" in node) {
+          const elseError = validateViewNode(node["else"], path + "/else");
+          if (elseError) return elseError;
+        }
       }
-    },
-    ParamExpr: {
-      type: "object",
-      required: ["expr", "name"],
-      additionalProperties: false,
-      properties: {
-        expr: { type: "string", const: "param" },
-        name: { type: "string" },
-        path: { type: "string" }
+      break;
+    case "each":
+      if (!("items" in node)) {
+        return { path: path + "/items", message: "items is required" };
       }
-    },
-    CondExpr: {
-      type: "object",
-      required: ["expr", "if", "then", "else"],
-      additionalProperties: false,
-      properties: {
-        expr: { type: "string", const: "cond" },
-        if: { $ref: "#/$defs/Expression" },
-        then: { $ref: "#/$defs/Expression" },
-        else: { $ref: "#/$defs/Expression" }
+      if (typeof node["as"] !== "string") {
+        return { path: path + "/as", message: "as is required" };
       }
-    },
-    GetExpr: {
-      type: "object",
-      required: ["expr", "base", "path"],
-      additionalProperties: false,
-      properties: {
-        expr: { type: "string", const: "get" },
-        base: { $ref: "#/$defs/Expression" },
-        path: { type: "string" }
+      if (!("body" in node)) {
+        return { path: path + "/body", message: "body is required" };
       }
-    },
-    // ==================== State Fields ====================
-    StateField: {
-      oneOf: [
-        { $ref: "#/$defs/NumberField" },
-        { $ref: "#/$defs/StringField" },
-        { $ref: "#/$defs/ListField" },
-        { $ref: "#/$defs/BooleanField" },
-        { $ref: "#/$defs/ObjectField" }
-      ]
-    },
-    NumberField: {
-      type: "object",
-      required: ["type", "initial"],
-      additionalProperties: false,
-      properties: {
-        type: { type: "string", const: "number" },
-        initial: { type: "number" }
+      {
+        const itemsError = validateExpression(node["items"], path + "/items");
+        if (itemsError) return itemsError;
+        const bodyError = validateViewNode(node["body"], path + "/body");
+        if (bodyError) return bodyError;
       }
-    },
-    StringField: {
-      type: "object",
-      required: ["type", "initial"],
-      additionalProperties: false,
-      properties: {
-        type: { type: "string", const: "string" },
-        initial: { type: "string" }
+      break;
+    case "component":
+      if (typeof node["name"] !== "string") {
+        return { path: path + "/name", message: "name is required" };
       }
-    },
-    ListField: {
-      type: "object",
-      required: ["type", "initial"],
-      additionalProperties: false,
-      properties: {
-        type: { type: "string", const: "list" },
-        initial: { type: "array" }
+      if (node["props"] !== void 0 && isObject2(node["props"])) {
+        for (const [propName, propValue] of Object.entries(node["props"])) {
+          const error = validateExpression(propValue, path + "/props/" + propName);
+          if (error) return error;
+        }
       }
-    },
-    BooleanField: {
-      type: "object",
-      required: ["type", "initial"],
-      additionalProperties: false,
-      properties: {
-        type: { type: "string", const: "boolean" },
-        initial: { type: "boolean" }
+      if (Array.isArray(node["children"])) {
+        for (let i = 0; i < node["children"].length; i++) {
+          const error = validateViewNode(node["children"][i], path + "/children/" + i);
+          if (error) return error;
+        }
       }
-    },
-    ObjectField: {
-      type: "object",
-      required: ["type", "initial"],
-      additionalProperties: false,
-      properties: {
-        type: { type: "string", const: "object" },
-        initial: { type: "object" }
+      break;
+    case "slot":
+      break;
+  }
+  return null;
+}
+function validateExpression(expr, path) {
+  if (!isObject2(expr)) {
+    return { path, message: "must be an object" };
+  }
+  const exprType = expr["expr"];
+  if (typeof exprType !== "string") {
+    return { path: path + "/expr", message: "expr is required" };
+  }
+  if (!VALID_EXPR_TYPES.includes(exprType)) {
+    return { path: path + "/expr", message: "must be one of: lit, state, var, bin, not, param" };
+  }
+  switch (exprType) {
+    case "lit":
+      if (!("value" in expr)) {
+        return { path: path + "/value", message: "value is required" };
       }
-    },
-    // ==================== Action Steps ====================
-    ActionStep: {
-      oneOf: [
-        { $ref: "#/$defs/SetStep" },
-        { $ref: "#/$defs/UpdateStep" },
-        { $ref: "#/$defs/FetchStep" }
-      ]
-    },
-    SetStep: {
-      type: "object",
-      required: ["do", "target", "value"],
-      additionalProperties: false,
-      properties: {
-        do: { type: "string", const: "set" },
-        target: { type: "string" },
-        value: { $ref: "#/$defs/Expression" }
+      break;
+    case "state":
+    case "var":
+      if (typeof expr["name"] !== "string") {
+        return { path: path + "/name", message: "name is required" };
       }
-    },
-    UpdateStep: {
-      type: "object",
-      required: ["do", "target", "operation"],
-      additionalProperties: false,
-      properties: {
-        do: { type: "string", const: "update" },
-        target: { type: "string" },
-        operation: {
-          type: "string",
-          enum: ["increment", "decrement", "push", "pop", "remove", "toggle", "merge", "replaceAt", "insertAt", "splice"]
-        },
-        value: { $ref: "#/$defs/Expression" },
-        index: { $ref: "#/$defs/Expression" },
-        deleteCount: { $ref: "#/$defs/Expression" }
+      break;
+    case "bin":
+      if (!("op" in expr)) {
+        return { path: path + "/op", message: "op is required" };
       }
-    },
-    FetchStep: {
-      type: "object",
-      required: ["do", "url"],
-      additionalProperties: false,
-      properties: {
-        do: { type: "string", const: "fetch" },
-        url: { $ref: "#/$defs/Expression" },
-        method: {
-          type: "string",
-          enum: ["GET", "POST", "PUT", "DELETE"]
-        },
-        body: { $ref: "#/$defs/Expression" },
-        result: { type: "string" },
-        onSuccess: {
-          type: "array",
-          items: { $ref: "#/$defs/ActionStep" }
-        },
-        onError: {
-          type: "array",
-          items: { $ref: "#/$defs/ActionStep" }
-        }
+      if (!VALID_BIN_OPS.includes(expr["op"])) {
+        return { path: path + "/op", message: "must be a valid operator" };
       }
-    },
-    // ==================== Event Handler ====================
-    EventHandler: {
-      type: "object",
-      required: ["event", "action"],
-      additionalProperties: false,
-      properties: {
-        event: { type: "string" },
-        action: { type: "string" },
-        payload: { $ref: "#/$defs/Expression" }
+      if (!("left" in expr)) {
+        return { path: path + "/left", message: "left is required" };
       }
-    },
-    // ==================== Action Definition ====================
-    ActionDefinition: {
-      type: "object",
-      required: ["name", "steps"],
-      additionalProperties: false,
-      properties: {
-        name: { type: "string" },
-        steps: {
-          type: "array",
-          items: { $ref: "#/$defs/ActionStep" }
-        }
+      if (!("right" in expr)) {
+        return { path: path + "/right", message: "right is required" };
       }
-    },
-    // ==================== View Nodes ====================
-    ViewNode: {
-      oneOf: [
-        { $ref: "#/$defs/ElementNode" },
-        { $ref: "#/$defs/TextNode" },
-        { $ref: "#/$defs/IfNode" },
-        { $ref: "#/$defs/EachNode" },
-        { $ref: "#/$defs/ComponentNode" },
-        { $ref: "#/$defs/SlotNode" }
-      ]
-    },
-    ElementNode: {
-      type: "object",
-      required: ["kind", "tag"],
-      additionalProperties: false,
-      properties: {
-        kind: { type: "string", const: "element" },
-        tag: { type: "string" },
-        props: {
-          type: "object",
-          additionalProperties: {
-            oneOf: [
-              { $ref: "#/$defs/Expression" },
-              { $ref: "#/$defs/EventHandler" }
-            ]
-          }
-        },
-        children: {
-          type: "array",
-          items: { $ref: "#/$defs/ViewNode" }
-        }
+      {
+        const leftError = validateExpression(expr["left"], path + "/left");
+        if (leftError) return leftError;
+        const rightError = validateExpression(expr["right"], path + "/right");
+        if (rightError) return rightError;
       }
-    },
-    TextNode: {
-      type: "object",
-      required: ["kind", "value"],
-      additionalProperties: false,
-      properties: {
-        kind: { type: "string", const: "text" },
-        value: { $ref: "#/$defs/Expression" }
+      break;
+    case "not":
+      if (!("operand" in expr)) {
+        return { path: path + "/operand", message: "operand is required" };
       }
-    },
-    IfNode: {
-      type: "object",
-      required: ["kind", "condition", "then"],
-      additionalProperties: false,
-      properties: {
-        kind: { type: "string", const: "if" },
-        condition: { $ref: "#/$defs/Expression" },
-        then: { $ref: "#/$defs/ViewNode" },
-        else: { $ref: "#/$defs/ViewNode" }
+      return validateExpression(expr["operand"], path + "/operand");
+    case "param":
+      if (typeof expr["name"] !== "string") {
+        return { path: path + "/name", message: "name is required" };
       }
-    },
-    EachNode: {
-      type: "object",
-      required: ["kind", "items", "as", "body"],
-      additionalProperties: false,
-      properties: {
-        kind: { type: "string", const: "each" },
-        items: { $ref: "#/$defs/Expression" },
-        as: { type: "string" },
-        index: { type: "string" },
-        key: { $ref: "#/$defs/Expression" },
-        body: { $ref: "#/$defs/ViewNode" }
+      if ("path" in expr && typeof expr["path"] !== "string") {
+        return { path: path + "/path", message: "path must be a string" };
       }
-    },
-    ComponentNode: {
-      type: "object",
-      required: ["kind", "name"],
-      additionalProperties: false,
-      properties: {
-        kind: { type: "string", const: "component" },
-        name: { type: "string" },
-        props: {
-          type: "object",
-          additionalProperties: { $ref: "#/$defs/Expression" }
-        },
-        children: {
-          type: "array",
-          items: { $ref: "#/$defs/ViewNode" }
-        }
+      break;
+  }
+  return null;
+}
+function validateActionStep(step, path) {
+  if (!isObject2(step)) {
+    return { path, message: "must be an object" };
+  }
+  const doType = step["do"];
+  if (typeof doType !== "string") {
+    return { path: path + "/do", message: "do is required" };
+  }
+  if (!VALID_ACTION_TYPES.includes(doType)) {
+    return { path: path + "/do", message: "must be one of: set, update, fetch" };
+  }
+  switch (doType) {
+    case "set":
+      if (typeof step["target"] !== "string") {
+        return { path: path + "/target", message: "target is required" };
       }
-    },
-    SlotNode: {
-      type: "object",
-      required: ["kind"],
-      additionalProperties: false,
-      properties: {
-        kind: { type: "string", const: "slot" }
+      if (!("value" in step)) {
+        return { path: path + "/value", message: "value is required" };
       }
-    },
-    // ==================== Component Definition ====================
-    ParamDef: {
-      type: "object",
-      required: ["type"],
-      additionalProperties: false,
-      properties: {
-        type: {
-          type: "string",
-          enum: ["string", "number", "boolean", "json"]
-        },
-        required: { type: "boolean" }
-      }
-    },
-    ComponentDef: {
-      type: "object",
-      required: ["view"],
-      additionalProperties: false,
-      properties: {
-        params: {
-          type: "object",
-          additionalProperties: { $ref: "#/$defs/ParamDef" }
-        },
-        view: { $ref: "#/$defs/ViewNode" }
-      }
-    }
-  }
-};
-
-// src/schema/validator.ts
-var ajv = new Ajv({
-  allErrors: true,
-  verbose: true,
-  strict: false
-});
-var validate = ajv.compile(astSchema);
-function isObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var VALID_VIEW_KINDS = ["element", "text", "if", "each", "component", "slot"];
-var VALID_EXPR_TYPES = ["lit", "state", "var", "bin", "not", "param"];
-var VALID_PARAM_TYPES = ["string", "number", "boolean", "json"];
-var VALID_ACTION_TYPES = ["set", "update", "fetch"];
-var VALID_STATE_TYPES = ["number", "string", "list", "boolean", "object"];
-var VALID_BIN_OPS = BINARY_OPERATORS;
-var VALID_UPDATE_OPS = UPDATE_OPERATIONS;
-var VALID_HTTP_METHODS = HTTP_METHODS;
-function validateViewNode(node, path) {
-  if (!isObject2(node)) {
-    return { path, message: "must be an object" };
-  }
-  const kind = node["kind"];
-  if (typeof kind !== "string") {
-    return { path: path + "/kind", message: "kind is required" };
-  }
-  if (!VALID_VIEW_KINDS.includes(kind)) {
-    return { path: path + "/kind", message: "must be one of: element, text, if, each, component, slot" };
-  }
-  switch (kind) {
-    case "element":
-      if (typeof node["tag"] !== "string") {
-        return { path: path + "/tag", message: "tag is required" };
-      }
-      if (node["props"] !== void 0 && isObject2(node["props"])) {
-        for (const [propName, propValue] of Object.entries(node["props"])) {
-          if (isObject2(propValue) && "event" in propValue) {
-          } else {
-            const error = validateExpression(propValue, path + "/props/" + propName);
-            if (error) return error;
-          }
-        }
-      }
-      if (Array.isArray(node["children"])) {
-        for (let i = 0; i < node["children"].length; i++) {
-          const error = validateViewNode(node["children"][i], path + "/children/" + i);
-          if (error) return error;
-        }
-      }
-      break;
-    case "text":
-      if (!("value" in node)) {
-        return { path: path + "/value", message: "value is required" };
-      }
-      return validateExpression(node["value"], path + "/value");
-    case "if":
-      if (!("condition" in node)) {
-        return { path: path + "/condition", message: "condition is required" };
-      }
-      if (!("then" in node)) {
-        return { path: path + "/then", message: "then is required" };
-      }
-      {
-        const condError = validateExpression(node["condition"], path + "/condition");
-        if (condError) return condError;
-        const thenError = validateViewNode(node["then"], path + "/then");
-        if (thenError) return thenError;
-        if ("else" in node) {
-          const elseError = validateViewNode(node["else"], path + "/else");
-          if (elseError) return elseError;
-        }
-      }
-      break;
-    case "each":
-      if (!("items" in node)) {
-        return { path: path + "/items", message: "items is required" };
-      }
-      if (typeof node["as"] !== "string") {
-        return { path: path + "/as", message: "as is required" };
-      }
-      if (!("body" in node)) {
-        return { path: path + "/body", message: "body is required" };
-      }
-      {
-        const itemsError = validateExpression(node["items"], path + "/items");
-        if (itemsError) return itemsError;
-        const bodyError = validateViewNode(node["body"], path + "/body");
-        if (bodyError) return bodyError;
-      }
-      break;
-    case "component":
-      if (typeof node["name"] !== "string") {
-        return { path: path + "/name", message: "name is required" };
-      }
-      if (node["props"] !== void 0 && isObject2(node["props"])) {
-        for (const [propName, propValue] of Object.entries(node["props"])) {
-          const error = validateExpression(propValue, path + "/props/" + propName);
-          if (error) return error;
-        }
-      }
-      if (Array.isArray(node["children"])) {
-        for (let i = 0; i < node["children"].length; i++) {
-          const error = validateViewNode(node["children"][i], path + "/children/" + i);
-          if (error) return error;
-        }
-      }
-      break;
-    case "slot":
-      break;
-  }
-  return null;
-}
-function validateExpression(expr, path) {
-  if (!isObject2(expr)) {
-    return { path, message: "must be an object" };
-  }
-  const exprType = expr["expr"];
-  if (typeof exprType !== "string") {
-    return { path: path + "/expr", message: "expr is required" };
-  }
-  if (!VALID_EXPR_TYPES.includes(exprType)) {
-    return { path: path + "/expr", message: "must be one of: lit, state, var, bin, not, param" };
-  }
-  switch (exprType) {
-    case "lit":
-      if (!("value" in expr)) {
-        return { path: path + "/value", message: "value is required" };
-      }
-      break;
-    case "state":
-    case "var":
-      if (typeof expr["name"] !== "string") {
-        return { path: path + "/name", message: "name is required" };
-      }
-      break;
-    case "bin":
-      if (!("op" in expr)) {
-        return { path: path + "/op", message: "op is required" };
-      }
-      if (!VALID_BIN_OPS.includes(expr["op"])) {
-        return { path: path + "/op", message: "must be a valid operator" };
-      }
-      if (!("left" in expr)) {
-        return { path: path + "/left", message: "left is required" };
-      }
-      if (!("right" in expr)) {
-        return { path: path + "/right", message: "right is required" };
-      }
-      {
-        const leftError = validateExpression(expr["left"], path + "/left");
-        if (leftError) return leftError;
-        const rightError = validateExpression(expr["right"], path + "/right");
-        if (rightError) return rightError;
-      }
-      break;
-    case "not":
-      if (!("operand" in expr)) {
-        return { path: path + "/operand", message: "operand is required" };
-      }
-      return validateExpression(expr["operand"], path + "/operand");
-    case "param":
-      if (typeof expr["name"] !== "string") {
-        return { path: path + "/name", message: "name is required" };
-      }
-      if ("path" in expr && typeof expr["path"] !== "string") {
-        return { path: path + "/path", message: "path must be a string" };
-      }
-      break;
-  }
-  return null;
-}
-function validateActionStep(step, path) {
-  if (!isObject2(step)) {
-    return { path, message: "must be an object" };
-  }
-  const doType = step["do"];
-  if (typeof doType !== "string") {
-    return { path: path + "/do", message: "do is required" };
-  }
-  if (!VALID_ACTION_TYPES.includes(doType)) {
-    return { path: path + "/do", message: "must be one of: set, update, fetch" };
-  }
-  switch (doType) {
-    case "set":
-      if (typeof step["target"] !== "string") {
-        return { path: path + "/target", message: "target is required" };
-      }
-      if (!("value" in step)) {
-        return { path: path + "/value", message: "value is required" };
-      }
-      return validateExpression(step["value"], path + "/value");
-    case "update":
-      if (typeof step["target"] !== "string") {
-        return { path: path + "/target", message: "target is required" };
+      return validateExpression(step["value"], path + "/value");
+    case "update":
+      if (typeof step["target"] !== "string") {
+        return { path: path + "/target", message: "target is required" };
       }
       if (!("operation" in step)) {
         return { path: path + "/operation", message: "operation is required" };
@@ -1051,20 +649,6 @@ function customValidateAst(input) {
   }
   return null;
 }
-function findTopLevelRequiredError(errors) {
-  for (const error of errors) {
-    if (error.keyword === "required" && error.instancePath === "") {
-      const params = error.params;
-      if (typeof params["missingProperty"] === "string") {
-        return {
-          path: "/" + params["missingProperty"],
-          message: error.message ?? "Required field missing"
-        };
-      }
-    }
-  }
-  return null;
-}
 function collectSemanticContext(ast) {
   const stateNames = /* @__PURE__ */ new Set();
   const actionNames = /* @__PURE__ */ new Set();
@@ -1200,37 +784,35 @@ function validateAst(input) {
       };
     }
   }
-  const valid = validate(input);
-  if (!valid && validate.errors && validate.errors.length > 0) {
-    const topLevelError = findTopLevelRequiredError(validate.errors);
-    if (topLevelError) {
-      return {
-        ok: false,
-        error: createSchemaError(topLevelError.message, topLevelError.path)
-      };
-    }
-    const customError = customValidateAst(input);
-    if (customError) {
-      return {
-        ok: false,
-        error: createSchemaError(customError.message, customError.path)
-      };
-    }
-    const firstError = validate.errors[0];
-    if (firstError) {
-      return {
-        ok: false,
-        error: createSchemaError(
-          firstError.message ?? "Schema validation failed",
-          firstError.instancePath || "/"
-        )
-      };
-    }
+  if (!("version" in input)) {
+    return {
+      ok: false,
+      error: createSchemaError("must have required property 'version'", "/version")
+    };
+  }
+  if (!("state" in input)) {
+    return {
+      ok: false,
+      error: createSchemaError("must have required property 'state'", "/state")
+    };
+  }
+  if (!("actions" in input)) {
+    return {
+      ok: false,
+      error: createSchemaError("must have required property 'actions'", "/actions")
+    };
+  }
+  if (!("view" in input)) {
+    return {
+      ok: false,
+      error: createSchemaError("must have required property 'view'", "/view")
+    };
   }
-  if (!valid) {
+  const customError = customValidateAst(input);
+  if (customError) {
     return {
       ok: false,
-      error: createSchemaError("Schema validation failed", "/")
+      error: createSchemaError(customError.message, customError.path)
     };
   }
   const semanticError = performSemanticValidation(input);
@@ -1245,6 +827,399 @@ function validateAst(input) {
     ast: input
   };
 }
+
+// src/schema/ast.schema.ts
+var astSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://constela.dev/schemas/ast.json",
+  title: "Constela AST",
+  description: "Schema for Constela UI framework AST",
+  type: "object",
+  required: ["version", "state", "actions", "view"],
+  additionalProperties: false,
+  properties: {
+    version: {
+      type: "string",
+      const: "1.0"
+    },
+    state: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/$defs/StateField"
+      }
+    },
+    actions: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/ActionDefinition"
+      }
+    },
+    view: {
+      $ref: "#/$defs/ViewNode"
+    },
+    components: {
+      type: "object",
+      additionalProperties: { $ref: "#/$defs/ComponentDef" }
+    }
+  },
+  $defs: {
+    // ==================== Expressions ====================
+    Expression: {
+      oneOf: [
+        { $ref: "#/$defs/LitExpr" },
+        { $ref: "#/$defs/StateExpr" },
+        { $ref: "#/$defs/VarExpr" },
+        { $ref: "#/$defs/BinExpr" },
+        { $ref: "#/$defs/NotExpr" },
+        { $ref: "#/$defs/ParamExpr" },
+        { $ref: "#/$defs/CondExpr" },
+        { $ref: "#/$defs/GetExpr" }
+      ]
+    },
+    LitExpr: {
+      type: "object",
+      required: ["expr", "value"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "lit" },
+        value: {
+          oneOf: [
+            { type: "string" },
+            { type: "number" },
+            { type: "boolean" },
+            { type: "null" },
+            { type: "array" }
+          ]
+        }
+      }
+    },
+    StateExpr: {
+      type: "object",
+      required: ["expr", "name"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "state" },
+        name: { type: "string" }
+      }
+    },
+    VarExpr: {
+      type: "object",
+      required: ["expr", "name"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "var" },
+        name: { type: "string" },
+        path: { type: "string" }
+      }
+    },
+    BinExpr: {
+      type: "object",
+      required: ["expr", "op", "left", "right"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "bin" },
+        op: {
+          type: "string",
+          enum: ["+", "-", "*", "/", "==", "!=", "<", "<=", ">", ">=", "&&", "||"]
+        },
+        left: { $ref: "#/$defs/Expression" },
+        right: { $ref: "#/$defs/Expression" }
+      }
+    },
+    NotExpr: {
+      type: "object",
+      required: ["expr", "operand"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "not" },
+        operand: { $ref: "#/$defs/Expression" }
+      }
+    },
+    ParamExpr: {
+      type: "object",
+      required: ["expr", "name"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "param" },
+        name: { type: "string" },
+        path: { type: "string" }
+      }
+    },
+    CondExpr: {
+      type: "object",
+      required: ["expr", "if", "then", "else"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "cond" },
+        if: { $ref: "#/$defs/Expression" },
+        then: { $ref: "#/$defs/Expression" },
+        else: { $ref: "#/$defs/Expression" }
+      }
+    },
+    GetExpr: {
+      type: "object",
+      required: ["expr", "base", "path"],
+      additionalProperties: false,
+      properties: {
+        expr: { type: "string", const: "get" },
+        base: { $ref: "#/$defs/Expression" },
+        path: { type: "string" }
+      }
+    },
+    // ==================== State Fields ====================
+    StateField: {
+      oneOf: [
+        { $ref: "#/$defs/NumberField" },
+        { $ref: "#/$defs/StringField" },
+        { $ref: "#/$defs/ListField" },
+        { $ref: "#/$defs/BooleanField" },
+        { $ref: "#/$defs/ObjectField" }
+      ]
+    },
+    NumberField: {
+      type: "object",
+      required: ["type", "initial"],
+      additionalProperties: false,
+      properties: {
+        type: { type: "string", const: "number" },
+        initial: { type: "number" }
+      }
+    },
+    StringField: {
+      type: "object",
+      required: ["type", "initial"],
+      additionalProperties: false,
+      properties: {
+        type: { type: "string", const: "string" },
+        initial: { type: "string" }
+      }
+    },
+    ListField: {
+      type: "object",
+      required: ["type", "initial"],
+      additionalProperties: false,
+      properties: {
+        type: { type: "string", const: "list" },
+        initial: { type: "array" }
+      }
+    },
+    BooleanField: {
+      type: "object",
+      required: ["type", "initial"],
+      additionalProperties: false,
+      properties: {
+        type: { type: "string", const: "boolean" },
+        initial: { type: "boolean" }
+      }
+    },
+    ObjectField: {
+      type: "object",
+      required: ["type", "initial"],
+      additionalProperties: false,
+      properties: {
+        type: { type: "string", const: "object" },
+        initial: { type: "object" }
+      }
+    },
+    // ==================== Action Steps ====================
+    ActionStep: {
+      oneOf: [
+        { $ref: "#/$defs/SetStep" },
+        { $ref: "#/$defs/UpdateStep" },
+        { $ref: "#/$defs/FetchStep" }
+      ]
+    },
+    SetStep: {
+      type: "object",
+      required: ["do", "target", "value"],
+      additionalProperties: false,
+      properties: {
+        do: { type: "string", const: "set" },
+        target: { type: "string" },
+        value: { $ref: "#/$defs/Expression" }
+      }
+    },
+    UpdateStep: {
+      type: "object",
+      required: ["do", "target", "operation"],
+      additionalProperties: false,
+      properties: {
+        do: { type: "string", const: "update" },
+        target: { type: "string" },
+        operation: {
+          type: "string",
+          enum: ["increment", "decrement", "push", "pop", "remove", "toggle", "merge", "replaceAt", "insertAt", "splice"]
+        },
+        value: { $ref: "#/$defs/Expression" },
+        index: { $ref: "#/$defs/Expression" },
+        deleteCount: { $ref: "#/$defs/Expression" }
+      }
+    },
+    FetchStep: {
+      type: "object",
+      required: ["do", "url"],
+      additionalProperties: false,
+      properties: {
+        do: { type: "string", const: "fetch" },
+        url: { $ref: "#/$defs/Expression" },
+        method: {
+          type: "string",
+          enum: ["GET", "POST", "PUT", "DELETE"]
+        },
+        body: { $ref: "#/$defs/Expression" },
+        result: { type: "string" },
+        onSuccess: {
+          type: "array",
+          items: { $ref: "#/$defs/ActionStep" }
+        },
+        onError: {
+          type: "array",
+          items: { $ref: "#/$defs/ActionStep" }
+        }
+      }
+    },
+    // ==================== Event Handler ====================
+    EventHandler: {
+      type: "object",
+      required: ["event", "action"],
+      additionalProperties: false,
+      properties: {
+        event: { type: "string" },
+        action: { type: "string" },
+        payload: { $ref: "#/$defs/Expression" }
+      }
+    },
+    // ==================== Action Definition ====================
+    ActionDefinition: {
+      type: "object",
+      required: ["name", "steps"],
+      additionalProperties: false,
+      properties: {
+        name: { type: "string" },
+        steps: {
+          type: "array",
+          items: { $ref: "#/$defs/ActionStep" }
+        }
+      }
+    },
+    // ==================== View Nodes ====================
+    ViewNode: {
+      oneOf: [
+        { $ref: "#/$defs/ElementNode" },
+        { $ref: "#/$defs/TextNode" },
+        { $ref: "#/$defs/IfNode" },
+        { $ref: "#/$defs/EachNode" },
+        { $ref: "#/$defs/ComponentNode" },
+        { $ref: "#/$defs/SlotNode" }
+      ]
+    },
+    ElementNode: {
+      type: "object",
+      required: ["kind", "tag"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "element" },
+        tag: { type: "string" },
+        props: {
+          type: "object",
+          additionalProperties: {
+            oneOf: [
+              { $ref: "#/$defs/Expression" },
+              { $ref: "#/$defs/EventHandler" }
+            ]
+          }
+        },
+        children: {
+          type: "array",
+          items: { $ref: "#/$defs/ViewNode" }
+        }
+      }
+    },
+    TextNode: {
+      type: "object",
+      required: ["kind", "value"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "text" },
+        value: { $ref: "#/$defs/Expression" }
+      }
+    },
+    IfNode: {
+      type: "object",
+      required: ["kind", "condition", "then"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "if" },
+        condition: { $ref: "#/$defs/Expression" },
+        then: { $ref: "#/$defs/ViewNode" },
+        else: { $ref: "#/$defs/ViewNode" }
+      }
+    },
+    EachNode: {
+      type: "object",
+      required: ["kind", "items", "as", "body"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "each" },
+        items: { $ref: "#/$defs/Expression" },
+        as: { type: "string" },
+        index: { type: "string" },
+        key: { $ref: "#/$defs/Expression" },
+        body: { $ref: "#/$defs/ViewNode" }
+      }
+    },
+    ComponentNode: {
+      type: "object",
+      required: ["kind", "name"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "component" },
+        name: { type: "string" },
+        props: {
+          type: "object",
+          additionalProperties: { $ref: "#/$defs/Expression" }
+        },
+        children: {
+          type: "array",
+          items: { $ref: "#/$defs/ViewNode" }
+        }
+      }
+    },
+    SlotNode: {
+      type: "object",
+      required: ["kind"],
+      additionalProperties: false,
+      properties: {
+        kind: { type: "string", const: "slot" }
+      }
+    },
+    // ==================== Component Definition ====================
+    ParamDef: {
+      type: "object",
+      required: ["type"],
+      additionalProperties: false,
+      properties: {
+        type: {
+          type: "string",
+          enum: ["string", "number", "boolean", "json"]
+        },
+        required: { type: "boolean" }
+      }
+    },
+    ComponentDef: {
+      type: "object",
+      required: ["view"],
+      additionalProperties: false,
+      properties: {
+        params: {
+          type: "object",
+          additionalProperties: { $ref: "#/$defs/ParamDef" }
+        },
+        view: { $ref: "#/$defs/ViewNode" }
+      }
+    }
+  }
+};
 export {
   BINARY_OPERATORS,
   ConstelaError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constela/core",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Core types, schema, and validator for Constela UI framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -14,9 +14,7 @@
   "files": [
     "dist"
   ],
-  "dependencies": {
-    "ajv": "^8.12.0"
-  },
+  "dependencies": {},
   "devDependencies": {
     "@types/node": "^20.10.0",
     "tsup": "^8.0.0",