@constela/core 0.1.0

package/dist/index.js

@@ -0,0 +1,976 @@
+// src/types/ast.ts
+var BINARY_OPERATORS = [
+  "+",
+  "-",
+  "*",
+  "/",
+  "==",
+  "!=",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "&&",
+  "||"
+];
+var UPDATE_OPERATIONS = [
+  "increment",
+  "decrement",
+  "push",
+  "pop",
+  "remove"
+];
+var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE"];
+
+// src/types/guards.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLitExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "lit") return false;
+  return "value" in value;
+}
+function isStateExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "state") return false;
+  return typeof value["name"] === "string";
+}
+function isVarExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "var") return false;
+  return typeof value["name"] === "string";
+}
+function isBinExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "bin") return false;
+  if (!BINARY_OPERATORS.includes(value["op"])) {
+    return false;
+  }
+  if (!isObject(value["left"]) || !isObject(value["right"])) return false;
+  return true;
+}
+function isNotExpr(value) {
+  if (!isObject(value)) return false;
+  if (value["expr"] !== "not") return false;
+  if (!isObject(value["operand"])) return false;
+  return true;
+}
+function isExpression(value) {
+  return isLitExpr(value) || isStateExpr(value) || isVarExpr(value) || isBinExpr(value) || isNotExpr(value);
+}
+function isElementNode(value) {
+  if (!isObject(value)) return false;
+  if (value["kind"] !== "element") return false;
+  return typeof value["tag"] === "string";
+}
+function isTextNode(value) {
+  if (!isObject(value)) return false;
+  if (value["kind"] !== "text") return false;
+  return isObject(value["value"]);
+}
+function isIfNode(value) {
+  if (!isObject(value)) return false;
+  if (value["kind"] !== "if") return false;
+  if (!isObject(value["condition"])) return false;
+  if (!isObject(value["then"])) return false;
+  return true;
+}
+function isEachNode(value) {
+  if (!isObject(value)) return false;
+  if (value["kind"] !== "each") return false;
+  if (!isObject(value["items"])) return false;
+  if (typeof value["as"] !== "string") return false;
+  if (!isObject(value["body"])) return false;
+  return true;
+}
+function isViewNode(value) {
+  return isElementNode(value) || isTextNode(value) || isIfNode(value) || isEachNode(value);
+}
+function isSetStep(value) {
+  if (!isObject(value)) return false;
+  if (value["do"] !== "set") return false;
+  if (typeof value["target"] !== "string") return false;
+  if (!isObject(value["value"])) return false;
+  return true;
+}
+function isUpdateStep(value) {
+  if (!isObject(value)) return false;
+  if (value["do"] !== "update") return false;
+  if (typeof value["target"] !== "string") return false;
+  if (!UPDATE_OPERATIONS.includes(value["operation"])) {
+    return false;
+  }
+  return true;
+}
+function isFetchStep(value) {
+  if (!isObject(value)) return false;
+  if (value["do"] !== "fetch") return false;
+  if (!isObject(value["url"])) return false;
+  if ("method" in value && value["method"] !== void 0) {
+    if (!HTTP_METHODS.includes(value["method"])) {
+      return false;
+    }
+  }
+  return true;
+}
+function isActionStep(value) {
+  return isSetStep(value) || isUpdateStep(value) || isFetchStep(value);
+}
+function isNumberField(value) {
+  if (!isObject(value)) return false;
+  if (value["type"] !== "number") return false;
+  return typeof value["initial"] === "number";
+}
+function isStringField(value) {
+  if (!isObject(value)) return false;
+  if (value["type"] !== "string") return false;
+  return typeof value["initial"] === "string";
+}
+function isListField(value) {
+  if (!isObject(value)) return false;
+  if (value["type"] !== "list") return false;
+  return Array.isArray(value["initial"]);
+}
+function isStateField(value) {
+  return isNumberField(value) || isStringField(value) || isListField(value);
+}
+function isEventHandler(value) {
+  if (!isObject(value)) return false;
+  if (!("event" in value) || typeof value["event"] !== "string") return false;
+  if (!("action" in value) || typeof value["action"] !== "string") return false;
+  return true;
+}
+
+// src/types/error.ts
+var ConstelaError = class _ConstelaError extends Error {
+  code;
+  path;
+  constructor(code, message, path) {
+    super(message);
+    this.name = "ConstelaError";
+    this.code = code;
+    this.path = path;
+    Object.setPrototypeOf(this, _ConstelaError.prototype);
+  }
+  /**
+   * Converts the error to a JSON-serializable object
+   */
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      path: this.path
+    };
+  }
+};
+function isConstelaError(value) {
+  return value instanceof ConstelaError;
+}
+function createSchemaError(message, path) {
+  return new ConstelaError("SCHEMA_INVALID", message, path);
+}
+function createUndefinedStateError(stateName, path) {
+  return new ConstelaError(
+    "UNDEFINED_STATE",
+    `Undefined state reference: '${stateName}' is not defined in state`,
+    path
+  );
+}
+function createUndefinedActionError(actionName, path) {
+  return new ConstelaError(
+    "UNDEFINED_ACTION",
+    `Undefined action reference: '${actionName}' is not defined in actions`,
+    path
+  );
+}
+function createDuplicateActionError(actionName, path) {
+  return new ConstelaError(
+    "DUPLICATE_ACTION",
+    `Duplicate action name: '${actionName}' is already defined`,
+    path
+  );
+}
+function createUndefinedVarError(varName, path) {
+  return new ConstelaError(
+    "VAR_UNDEFINED",
+    `Undefined variable reference: '${varName}' is not defined in scope`,
+    path
+  );
+}
+function createUnsupportedVersionError(version) {
+  return new ConstelaError(
+    "UNSUPPORTED_VERSION",
+    `Unsupported version: '${version}'. Supported versions: 1.0`,
+    "/version"
+  );
+}
+
+// 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"
+      }
+    },
+    actions: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/ActionDefinition"
+      }
+    },
+    view: {
+      $ref: "#/$defs/ViewNode"
+    }
+  },
+  $defs: {
+    // ==================== Expressions ====================
+    Expression: {
+      oneOf: [
+        { $ref: "#/$defs/LitExpr" },
+        { $ref: "#/$defs/StateExpr" },
+        { $ref: "#/$defs/VarExpr" },
+        { $ref: "#/$defs/BinExpr" },
+        { $ref: "#/$defs/NotExpr" }
+      ]
+    },
+    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" }
+      }
+    },
+    // ==================== State Fields ====================
+    StateField: {
+      oneOf: [
+        { $ref: "#/$defs/NumberField" },
+        { $ref: "#/$defs/StringField" },
+        { $ref: "#/$defs/ListField" }
+      ]
+    },
+    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" }
+      }
+    },
+    // ==================== 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"]
+        },
+        value: { $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" }
+      ]
+    },
+    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" }
+      }
+    }
+  }
+};
+
+// 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"];
+var VALID_EXPR_TYPES = ["lit", "state", "var", "bin", "not"];
+var VALID_ACTION_TYPES = ["set", "update", "fetch"];
+var VALID_STATE_TYPES = ["number", "string", "list"];
+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" };
+  }
+  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;
+  }
+  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" };
+  }
+  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");
+  }
+  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" };
+      }
+      if (!("operation" in step)) {
+        return { path: path + "/operation", message: "operation is required" };
+      }
+      if (!VALID_UPDATE_OPS.includes(step["operation"])) {
+        return { path: path + "/operation", message: "must be a valid operation" };
+      }
+      if ("value" in step) {
+        return validateExpression(step["value"], path + "/value");
+      }
+      break;
+    case "fetch":
+      if (!("url" in step)) {
+        return { path: path + "/url", message: "url is required" };
+      }
+      {
+        const urlError = validateExpression(step["url"], path + "/url");
+        if (urlError) return urlError;
+      }
+      if ("method" in step) {
+        if (!VALID_HTTP_METHODS.includes(step["method"])) {
+          return { path: path + "/method", message: "must be a valid HTTP method" };
+        }
+      }
+      if ("body" in step) {
+        const bodyError = validateExpression(step["body"], path + "/body");
+        if (bodyError) return bodyError;
+      }
+      break;
+  }
+  return null;
+}
+function validateStateField(field, path) {
+  if (!isObject2(field)) {
+    return { path, message: "must be an object" };
+  }
+  const fieldType = field["type"];
+  if (typeof fieldType !== "string") {
+    return { path: path + "/type", message: "type is required" };
+  }
+  if (!VALID_STATE_TYPES.includes(fieldType)) {
+    return { path: path + "/type", message: "must be one of: number, string, list" };
+  }
+  if (!("initial" in field)) {
+    return { path: path + "/initial", message: "initial is required" };
+  }
+  switch (fieldType) {
+    case "number":
+      if (typeof field["initial"] !== "number") {
+        return { path: path + "/initial", message: "must be a number" };
+      }
+      break;
+    case "string":
+      if (typeof field["initial"] !== "string") {
+        return { path: path + "/initial", message: "must be a string" };
+      }
+      break;
+    case "list":
+      if (!Array.isArray(field["initial"])) {
+        return { path: path + "/initial", message: "must be an array" };
+      }
+      break;
+  }
+  return null;
+}
+function customValidateAst(input) {
+  if (isObject2(input["state"])) {
+    for (const [name, field] of Object.entries(input["state"])) {
+      const error = validateStateField(field, "/state/" + name);
+      if (error) return error;
+    }
+  }
+  if (Array.isArray(input["actions"])) {
+    for (let i = 0; i < input["actions"].length; i++) {
+      const action = input["actions"][i];
+      if (isObject2(action) && Array.isArray(action["steps"])) {
+        for (let j = 0; j < action["steps"].length; j++) {
+          const error = validateActionStep(action["steps"][j], "/actions/" + i + "/steps/" + j);
+          if (error) return error;
+        }
+      }
+    }
+  }
+  if ("view" in input) {
+    const error = validateViewNode(input["view"], "/view");
+    if (error) return error;
+  }
+  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();
+  if (isObject2(ast["state"])) {
+    for (const name of Object.keys(ast["state"])) {
+      stateNames.add(name);
+    }
+  }
+  if (Array.isArray(ast["actions"])) {
+    for (const action of ast["actions"]) {
+      if (isObject2(action) && typeof action["name"] === "string") {
+        actionNames.add(action["name"]);
+      }
+    }
+  }
+  return { stateNames, actionNames };
+}
+function validateStateReferences(node, path, stateNames) {
+  if (!isObject2(node)) return null;
+  if (node["expr"] === "state" && typeof node["name"] === "string") {
+    if (!stateNames.has(node["name"])) {
+      return createUndefinedStateError(node["name"], path + "/" + node["name"]);
+    }
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (isObject2(value)) {
+      const error = validateStateReferences(value, path + "/" + key, stateNames);
+      if (error) return error;
+    } else if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const error = validateStateReferences(value[i], path + "/" + key + "/" + i, stateNames);
+        if (error) return error;
+      }
+    }
+  }
+  return null;
+}
+function validateActionTargets(ast, stateNames) {
+  if (!Array.isArray(ast["actions"])) return null;
+  for (let i = 0; i < ast["actions"].length; i++) {
+    const action = ast["actions"][i];
+    if (!isObject2(action) || !Array.isArray(action["steps"])) continue;
+    for (let j = 0; j < action["steps"].length; j++) {
+      const step = action["steps"][j];
+      if (!isObject2(step)) continue;
+      if ((step["do"] === "set" || step["do"] === "update") && typeof step["target"] === "string") {
+        if (!stateNames.has(step["target"])) {
+          return createUndefinedStateError(step["target"], "/actions/" + i + "/steps/" + j + "/target");
+        }
+      }
+    }
+  }
+  return null;
+}
+function validateActionReferences(node, path, actionNames) {
+  if (!isObject2(node)) return null;
+  if (isObject2(node["props"])) {
+    for (const [propName, propValue] of Object.entries(node["props"])) {
+      if (isObject2(propValue) && "event" in propValue && "action" in propValue) {
+        const actionName = propValue["action"];
+        if (typeof actionName === "string" && !actionNames.has(actionName)) {
+          return createUndefinedActionError(actionName, path + "/props/" + propName);
+        }
+      }
+    }
+  }
+  if (Array.isArray(node["children"])) {
+    for (let i = 0; i < node["children"].length; i++) {
+      const error = validateActionReferences(
+        node["children"][i],
+        path + "/children/" + i,
+        actionNames
+      );
+      if (error) return error;
+    }
+  }
+  if (isObject2(node["then"])) {
+    const error = validateActionReferences(node["then"], path + "/then", actionNames);
+    if (error) return error;
+  }
+  if (isObject2(node["else"])) {
+    const error = validateActionReferences(node["else"], path + "/else", actionNames);
+    if (error) return error;
+  }
+  if (isObject2(node["body"])) {
+    const error = validateActionReferences(node["body"], path + "/body", actionNames);
+    if (error) return error;
+  }
+  return null;
+}
+function validateDuplicateActions(ast) {
+  if (!Array.isArray(ast["actions"])) return null;
+  const seenNames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < ast["actions"].length; i++) {
+    const action = ast["actions"][i];
+    if (!isObject2(action) || typeof action["name"] !== "string") continue;
+    const name = action["name"];
+    if (seenNames.has(name)) {
+      return createDuplicateActionError(name, "/actions/" + i);
+    }
+    seenNames.add(name);
+  }
+  return null;
+}
+function performSemanticValidation(ast) {
+  const { stateNames, actionNames } = collectSemanticContext(ast);
+  const duplicateError = validateDuplicateActions(ast);
+  if (duplicateError) return duplicateError;
+  if (isObject2(ast["view"])) {
+    const stateRefError = validateStateReferences(ast["view"], "/view", stateNames);
+    if (stateRefError) return stateRefError;
+  }
+  const actionTargetError = validateActionTargets(ast, stateNames);
+  if (actionTargetError) return actionTargetError;
+  if (isObject2(ast["view"])) {
+    const actionRefError = validateActionReferences(ast["view"], "/view", actionNames);
+    if (actionRefError) return actionRefError;
+  }
+  return null;
+}
+function validateAst(input) {
+  if (!isObject2(input)) {
+    return {
+      ok: false,
+      error: createSchemaError("Input must be an object", "/")
+    };
+  }
+  if ("version" in input && input["version"] !== "1.0") {
+    if (typeof input["version"] === "string") {
+      return {
+        ok: false,
+        error: createUnsupportedVersionError(input["version"])
+      };
+    }
+  }
+  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 (!valid) {
+    return {
+      ok: false,
+      error: createSchemaError("Schema validation failed", "/")
+    };
+  }
+  const semanticError = performSemanticValidation(input);
+  if (semanticError) {
+    return {
+      ok: false,
+      error: semanticError
+    };
+  }
+  return {
+    ok: true,
+    ast: input
+  };
+}
+export {
+  BINARY_OPERATORS,
+  ConstelaError,
+  HTTP_METHODS,
+  UPDATE_OPERATIONS,
+  astSchema,
+  createDuplicateActionError,
+  createSchemaError,
+  createUndefinedActionError,
+  createUndefinedStateError,
+  createUndefinedVarError,
+  createUnsupportedVersionError,
+  isActionStep,
+  isBinExpr,
+  isConstelaError,
+  isEachNode,
+  isElementNode,
+  isEventHandler,
+  isExpression,
+  isFetchStep,
+  isIfNode,
+  isListField,
+  isLitExpr,
+  isNotExpr,
+  isNumberField,
+  isSetStep,
+  isStateExpr,
+  isStateField,
+  isStringField,
+  isTextNode,
+  isUpdateStep,
+  isVarExpr,
+  isViewNode,
+  validateAst
+};