@manifesto-ai/compiler 1.6.1 → 1.7.0

package/dist/chunk-QP2LGMBA.js

@@ -0,0 +1,4522 @@
+// src/lexer/tokens.ts
+var KEYWORDS = {
+  domain: "DOMAIN",
+  state: "STATE",
+  computed: "COMPUTED",
+  action: "ACTION",
+  effect: "EFFECT",
+  when: "WHEN",
+  once: "ONCE",
+  patch: "PATCH",
+  unset: "UNSET",
+  merge: "MERGE",
+  true: "TRUE",
+  false: "FALSE",
+  null: "NULL",
+  as: "AS",
+  available: "AVAILABLE",
+  // v0.3.2
+  fail: "FAIL",
+  // v0.3.2
+  stop: "STOP",
+  // v0.3.2
+  with: "WITH",
+  // v0.3.2
+  type: "TYPE",
+  // v0.3.3
+  import: "IMPORT",
+  from: "FROM",
+  export: "EXPORT"
+};
+var RESERVED_KEYWORDS = /* @__PURE__ */ new Set([
+  // Control flow (forbidden)
+  "function",
+  "var",
+  "let",
+  "const",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "return",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "new",
+  "delete",
+  "instanceof",
+  "void",
+  // NOTE: "typeof" removed - now a MEL builtin function
+  // NOTE: "with" removed - now a MEL keyword in v0.3.2
+  "debugger",
+  "this",
+  "super",
+  "arguments",
+  "eval",
+  // Reserved for future
+  "async",
+  "await",
+  "yield",
+  "class",
+  "extends",
+  "interface",
+  "enum",
+  "namespace",
+  "module"
+  // NOTE: "type" removed - now a MEL keyword in v0.3.3
+]);
+function isKeyword(lexeme) {
+  return lexeme in KEYWORDS;
+}
+function isReserved(lexeme) {
+  return RESERVED_KEYWORDS.has(lexeme);
+}
+function getKeywordKind(lexeme) {
+  return Object.hasOwn(KEYWORDS, lexeme) ? KEYWORDS[lexeme] : void 0;
+}
+function createToken(kind, lexeme, location, value) {
+  return { kind, lexeme, location, value };
+}
+
+// src/lexer/source-location.ts
+function createPosition(line, column, offset) {
+  return { line, column, offset };
+}
+function createLocation(start, end, source) {
+  return { start, end, source };
+}
+function createPointLocation(pos, source) {
+  return { start: pos, end: pos, source };
+}
+function mergeLocations(a, b) {
+  return {
+    start: a.start.offset < b.start.offset ? a.start : b.start,
+    end: a.end.offset > b.end.offset ? a.end : b.end,
+    source: a.source ?? b.source
+  };
+}
+
+// src/lexer/lexer.ts
+var Lexer = class {
+  source;
+  sourcePath;
+  tokens = [];
+  diagnostics = [];
+  // Current position
+  start = 0;
+  // Start of current token
+  current = 0;
+  // Current character
+  line = 1;
+  column = 1;
+  lineStart = 0;
+  // Offset of current line start
+  constructor(source, sourcePath) {
+    this.source = source;
+    this.sourcePath = sourcePath;
+  }
+  /**
+   * Tokenize the source code
+   */
+  tokenize() {
+    while (!this.isAtEnd()) {
+      this.start = this.current;
+      this.scanToken();
+    }
+    this.tokens.push(
+      createToken("EOF", "", this.currentLocation())
+    );
+    return {
+      tokens: this.tokens,
+      diagnostics: this.diagnostics
+    };
+  }
+  scanToken() {
+    const c = this.advance();
+    switch (c) {
+      // Single-character tokens
+      case "(":
+        this.addToken("LPAREN");
+        break;
+      case ")":
+        this.addToken("RPAREN");
+        break;
+      case "{":
+        this.addToken("LBRACE");
+        break;
+      case "}":
+        this.addToken("RBRACE");
+        break;
+      case "[":
+        this.addToken("LBRACKET");
+        break;
+      case "]":
+        this.addToken("RBRACKET");
+        break;
+      case ",":
+        this.addToken("COMMA");
+        break;
+      case ";":
+        this.addToken("SEMICOLON");
+        break;
+      case ".":
+        this.addToken("DOT");
+        break;
+      case "+":
+        this.addToken("PLUS");
+        break;
+      case "-":
+        this.addToken("MINUS");
+        break;
+      case "*":
+        this.addToken("STAR");
+        break;
+      case "%":
+        this.addToken("PERCENT");
+        break;
+      case ":":
+        this.addToken("COLON");
+        break;
+      // Two-character tokens
+      case "=":
+        this.addToken(this.match("=") ? "EQ_EQ" : "EQ");
+        break;
+      case "!":
+        this.addToken(this.match("=") ? "BANG_EQ" : "BANG");
+        break;
+      case "<":
+        this.addToken(this.match("=") ? "LT_EQ" : "LT");
+        break;
+      case ">":
+        this.addToken(this.match("=") ? "GT_EQ" : "GT");
+        break;
+      case "&":
+        if (this.match("&")) {
+          this.addToken("AMP_AMP");
+        } else {
+          this.error("Expected '&&' for logical AND");
+        }
+        break;
+      case "|":
+        if (this.match("|")) {
+          this.addToken("PIPE_PIPE");
+        } else {
+          this.addToken("PIPE");
+        }
+        break;
+      case "?":
+        this.addToken(this.match("?") ? "QUESTION_QUESTION" : "QUESTION");
+        break;
+      // Slash or comment
+      case "/":
+        if (this.match("/")) {
+          this.lineComment();
+        } else if (this.match("*")) {
+          this.blockComment();
+        } else {
+          this.addToken("SLASH");
+        }
+        break;
+      // Whitespace
+      case " ":
+      case "\r":
+      case "	":
+        break;
+      case "\n":
+        this.newline();
+        break;
+      // String literals
+      case '"':
+        this.string('"');
+        break;
+      case "'":
+        this.string("'");
+        break;
+      // System identifiers ($...)
+      case "$":
+        this.systemIdentifier();
+        break;
+      default:
+        if (this.isDigit(c)) {
+          this.number();
+        } else if (this.isAlpha(c)) {
+          this.identifier();
+        } else {
+          this.error(`Unexpected character '${c}'`);
+        }
+    }
+  }
+  // ============ Token Scanners ============
+  lineComment() {
+    while (this.peek() !== "\n" && !this.isAtEnd()) {
+      this.advance();
+    }
+  }
+  blockComment() {
+    const startLine = this.line;
+    const startColumn = this.column - 2;
+    while (!this.isAtEnd()) {
+      if (this.peek() === "*" && this.peekNext() === "/") {
+        this.advance();
+        this.advance();
+        return;
+      }
+      if (this.peek() === "\n") {
+        this.newline();
+      }
+      this.advance();
+    }
+    this.error(`Unterminated block comment starting at line ${startLine}:${startColumn}`);
+  }
+  string(quote) {
+    const startLine = this.line;
+    const startColumn = this.column - 1;
+    let value = "";
+    while (this.peek() !== quote && !this.isAtEnd()) {
+      if (this.peek() === "\n") {
+        this.error("Unterminated string literal");
+        return;
+      }
+      if (this.peek() === "\\") {
+        this.advance();
+        const escaped = this.advance();
+        switch (escaped) {
+          case "n":
+            value += "\n";
+            break;
+          case "r":
+            value += "\r";
+            break;
+          case "t":
+            value += "	";
+            break;
+          case "\\":
+            value += "\\";
+            break;
+          case "'":
+            value += "'";
+            break;
+          case '"':
+            value += '"';
+            break;
+          case "0":
+            value += "\0";
+            break;
+          default:
+            this.error(`Invalid escape sequence '\\${escaped}'`);
+            value += escaped;
+        }
+      } else {
+        value += this.advance();
+      }
+    }
+    if (this.isAtEnd()) {
+      this.error(`Unterminated string starting at line ${startLine}:${startColumn}`);
+      return;
+    }
+    this.advance();
+    this.addToken("STRING", value);
+  }
+  number() {
+    if (this.source[this.start] === "0" && (this.peek() === "x" || this.peek() === "X")) {
+      this.advance();
+      while (this.isHexDigit(this.peek())) {
+        this.advance();
+      }
+      const hexStr = this.source.slice(this.start + 2, this.current);
+      const value2 = parseInt(hexStr, 16);
+      this.addToken("NUMBER", value2);
+      return;
+    }
+    while (this.isDigit(this.peek())) {
+      this.advance();
+    }
+    if (this.peek() === "." && this.isDigit(this.peekNext())) {
+      this.advance();
+      while (this.isDigit(this.peek())) {
+        this.advance();
+      }
+    }
+    if (this.peek() === "e" || this.peek() === "E") {
+      this.advance();
+      if (this.peek() === "+" || this.peek() === "-") {
+        this.advance();
+      }
+      if (!this.isDigit(this.peek())) {
+        this.error("Invalid number: expected digits after exponent");
+        return;
+      }
+      while (this.isDigit(this.peek())) {
+        this.advance();
+      }
+    }
+    const value = parseFloat(this.source.slice(this.start, this.current));
+    this.addToken("NUMBER", value);
+  }
+  identifier() {
+    while (this.isAlphaNumeric(this.peek())) {
+      if (this.peek() === "$") {
+        this.advance();
+        this.error("'$' is forbidden in identifiers (MEL A17)");
+        continue;
+      }
+      this.advance();
+    }
+    const lexeme = this.source.slice(this.start, this.current);
+    if (lexeme.startsWith("__sys__")) {
+      this.error("'__sys__' prefix is reserved for compiler-generated identifiers (MEL A26)");
+      this.addToken("ERROR");
+      return;
+    }
+    if (isReserved(lexeme)) {
+      this.error(`'${lexeme}' is a reserved keyword and cannot be used`);
+      this.addToken("ERROR");
+      return;
+    }
+    const keywordKind = getKeywordKind(lexeme);
+    if (keywordKind) {
+      this.addToken(keywordKind);
+    } else {
+      this.addToken("IDENTIFIER");
+    }
+  }
+  systemIdentifier() {
+    if (!this.isAlpha(this.peek())) {
+      this.error("Expected identifier after '$'");
+      this.addToken("ERROR");
+      return;
+    }
+    while (this.isAlphaNumeric(this.peek())) {
+      this.advance();
+    }
+    const initialLexeme = this.source.slice(this.start, this.current);
+    if (initialLexeme === "$item") {
+      this.addToken("ITEM");
+      return;
+    }
+    if (initialLexeme === "$system" || initialLexeme === "$meta" || initialLexeme === "$input") {
+      while (this.peek() === "." && this.isAlpha(this.peekNext())) {
+        this.advance();
+        while (this.isAlphaNumeric(this.peek())) {
+          this.advance();
+        }
+      }
+      this.addToken("SYSTEM_IDENT");
+      return;
+    }
+    this.error(`Invalid system identifier '${initialLexeme}'. Expected $system.*, $meta.*, $input.*, or $item`);
+    this.addToken("ERROR");
+  }
+  // ============ Helpers ============
+  isAtEnd() {
+    return this.current >= this.source.length;
+  }
+  advance() {
+    const c = this.source[this.current];
+    this.current++;
+    this.column++;
+    return c;
+  }
+  peek() {
+    if (this.isAtEnd()) return "\0";
+    return this.source[this.current];
+  }
+  peekNext() {
+    if (this.current + 1 >= this.source.length) return "\0";
+    return this.source[this.current + 1];
+  }
+  match(expected) {
+    if (this.isAtEnd()) return false;
+    if (this.source[this.current] !== expected) return false;
+    this.current++;
+    this.column++;
+    return true;
+  }
+  newline() {
+    this.line++;
+    this.column = 1;
+    this.lineStart = this.current;
+  }
+  isDigit(c) {
+    return c >= "0" && c <= "9";
+  }
+  isHexDigit(c) {
+    return this.isDigit(c) || c >= "a" && c <= "f" || c >= "A" && c <= "F";
+  }
+  isAlpha(c) {
+    return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+  }
+  isAlphaNumeric(c) {
+    return this.isAlpha(c) || this.isDigit(c);
+  }
+  currentLocation() {
+    const startPos = this.positionAt(this.start);
+    const endPos = this.positionAt(this.current);
+    return createLocation(startPos, endPos, this.sourcePath);
+  }
+  positionAt(offset) {
+    let line = 1;
+    let lineStart = 0;
+    for (let i = 0; i < offset; i++) {
+      if (this.source[i] === "\n") {
+        line++;
+        lineStart = i + 1;
+      }
+    }
+    return createPosition(line, offset - lineStart + 1, offset);
+  }
+  addToken(kind, value) {
+    const lexeme = this.source.slice(this.start, this.current);
+    this.tokens.push(createToken(kind, lexeme, this.currentLocation(), value));
+  }
+  error(message) {
+    const location = this.currentLocation();
+    this.diagnostics.push({
+      severity: "error",
+      code: "MEL_LEXER",
+      message,
+      location,
+      source: this.getSourceLine(location.start.line)
+    });
+  }
+  getSourceLine(lineNumber) {
+    const lines = this.source.split("\n");
+    return lines[lineNumber - 1] ?? "";
+  }
+};
+function tokenize(source, sourcePath) {
+  const lexer = new Lexer(source, sourcePath);
+  return lexer.tokenize();
+}
+
+// src/parser/ast.ts
+function isExprNode(node) {
+  const exprKinds = [
+    "literal",
+    "identifier",
+    "systemIdent",
+    "iterationVar",
+    "propertyAccess",
+    "indexAccess",
+    "functionCall",
+    "unary",
+    "binary",
+    "ternary",
+    "objectLiteral",
+    "arrayLiteral"
+  ];
+  return exprKinds.includes(node.kind);
+}
+function isStmtNode(node) {
+  const stmtKinds = ["when", "once", "onceIntent", "patch", "effect", "fail", "stop"];
+  return stmtKinds.includes(node.kind);
+}
+
+// src/parser/precedence.ts
+var Precedence = /* @__PURE__ */ ((Precedence2) => {
+  Precedence2[Precedence2["NONE"] = 0] = "NONE";
+  Precedence2[Precedence2["TERNARY"] = 1] = "TERNARY";
+  Precedence2[Precedence2["NULLISH"] = 2] = "NULLISH";
+  Precedence2[Precedence2["OR"] = 3] = "OR";
+  Precedence2[Precedence2["AND"] = 4] = "AND";
+  Precedence2[Precedence2["EQUALITY"] = 5] = "EQUALITY";
+  Precedence2[Precedence2["COMPARISON"] = 6] = "COMPARISON";
+  Precedence2[Precedence2["ADDITIVE"] = 7] = "ADDITIVE";
+  Precedence2[Precedence2["MULTIPLICATIVE"] = 8] = "MULTIPLICATIVE";
+  Precedence2[Precedence2["UNARY"] = 9] = "UNARY";
+  Precedence2[Precedence2["CALL"] = 10] = "CALL";
+  Precedence2[Precedence2["ACCESS"] = 11] = "ACCESS";
+  return Precedence2;
+})(Precedence || {});
+function getBinaryPrecedence(kind) {
+  switch (kind) {
+    case "QUESTION":
+      return 1 /* TERNARY */;
+    case "QUESTION_QUESTION":
+      return 2 /* NULLISH */;
+    case "PIPE_PIPE":
+      return 3 /* OR */;
+    case "AMP_AMP":
+      return 4 /* AND */;
+    case "EQ_EQ":
+    case "BANG_EQ":
+      return 5 /* EQUALITY */;
+    case "LT":
+    case "LT_EQ":
+    case "GT":
+    case "GT_EQ":
+      return 6 /* COMPARISON */;
+    case "PLUS":
+    case "MINUS":
+      return 7 /* ADDITIVE */;
+    case "STAR":
+    case "SLASH":
+    case "PERCENT":
+      return 8 /* MULTIPLICATIVE */;
+    default:
+      return 0 /* NONE */;
+  }
+}
+function tokenToBinaryOp(kind) {
+  switch (kind) {
+    case "PLUS":
+      return "+";
+    case "MINUS":
+      return "-";
+    case "STAR":
+      return "*";
+    case "SLASH":
+      return "/";
+    case "PERCENT":
+      return "%";
+    case "EQ_EQ":
+      return "==";
+    case "BANG_EQ":
+      return "!=";
+    case "LT":
+      return "<";
+    case "LT_EQ":
+      return "<=";
+    case "GT":
+      return ">";
+    case "GT_EQ":
+      return ">=";
+    case "AMP_AMP":
+      return "&&";
+    case "PIPE_PIPE":
+      return "||";
+    case "QUESTION_QUESTION":
+      return "??";
+    default:
+      return null;
+  }
+}
+function isBinaryOp(kind) {
+  return getBinaryPrecedence(kind) !== 0 /* NONE */;
+}
+function isUnaryOp(kind) {
+  return kind === "BANG" || kind === "MINUS";
+}
+function isRightAssociative(kind) {
+  return kind === "QUESTION" || kind === "QUESTION_QUESTION";
+}
+
+// src/parser/parser.ts
+var Parser = class {
+  tokens;
+  current = 0;
+  diagnostics = [];
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  /**
+   * Parse tokens into an AST
+   */
+  parse() {
+    try {
+      const program = this.parseProgram();
+      return { program, diagnostics: this.diagnostics };
+    } catch (e) {
+      return { program: null, diagnostics: this.diagnostics };
+    }
+  }
+  // ============ Program Structure ============
+  parseProgram() {
+    const start = this.peek().location;
+    const imports = [];
+    while (this.check("IMPORT")) {
+      imports.push(this.parseImport());
+    }
+    const domain = this.parseDomain();
+    return {
+      kind: "program",
+      imports,
+      domain,
+      location: mergeLocations(start, domain.location)
+    };
+  }
+  parseImport() {
+    const start = this.consume("IMPORT", "Expected 'import'").location;
+    this.consume("LBRACE", "Expected '{' after 'import'");
+    const names = [];
+    do {
+      names.push(this.consume("IDENTIFIER", "Expected identifier").lexeme);
+    } while (this.match("COMMA"));
+    this.consume("RBRACE", "Expected '}' after import names");
+    this.consume("FROM", "Expected 'from' after import names");
+    const fromToken = this.consume("STRING", "Expected string after 'from'");
+    return {
+      kind: "import",
+      names,
+      from: fromToken.value,
+      location: mergeLocations(start, fromToken.location)
+    };
+  }
+  parseDomain() {
+    const start = this.consume("DOMAIN", "Expected 'domain'").location;
+    const name = this.consume("IDENTIFIER", "Expected domain name").lexeme;
+    this.consume("LBRACE", "Expected '{' after domain name");
+    const types = [];
+    while (this.check("TYPE") && !this.isAtEnd()) {
+      types.push(this.parseTypeDecl());
+    }
+    const members = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      if (this.check("TYPE")) {
+        types.push(this.parseTypeDecl());
+      } else {
+        const member = this.parseDomainMember();
+        if (member) members.push(member);
+      }
+    }
+    const end = this.consume("RBRACE", "Expected '}' to close domain").location;
+    return {
+      kind: "domain",
+      name,
+      types,
+      members,
+      location: mergeLocations(start, end)
+    };
+  }
+  /**
+   * v0.3.3: Parse type declaration
+   * Syntax: type Name = TypeExpr
+   */
+  parseTypeDecl() {
+    const start = this.consume("TYPE", "Expected 'type'").location;
+    const name = this.consume("IDENTIFIER", "Expected type name").lexeme;
+    this.consume("EQ", "Expected '=' after type name");
+    const typeExpr = this.parseTypeExpr();
+    return {
+      kind: "typeDecl",
+      name,
+      typeExpr,
+      location: mergeLocations(start, typeExpr.location)
+    };
+  }
+  parseDomainMember() {
+    if (this.check("STATE")) return this.parseState();
+    if (this.check("COMPUTED")) return this.parseComputed();
+    if (this.check("ACTION")) return this.parseAction();
+    this.error(`Unexpected token '${this.peek().lexeme}'. Expected 'state', 'computed', or 'action'.`);
+    this.advance();
+    return null;
+  }
+  // ============ State ============
+  parseState() {
+    const start = this.consume("STATE", "Expected 'state'").location;
+    this.consume("LBRACE", "Expected '{' after 'state'");
+    const fields = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      fields.push(this.parseStateField());
+    }
+    const end = this.consume("RBRACE", "Expected '}' to close state block").location;
+    return {
+      kind: "state",
+      fields,
+      location: mergeLocations(start, end)
+    };
+  }
+  parseStateField() {
+    const nameToken = this.consume("IDENTIFIER", "Expected field name");
+    this.consume("COLON", "Expected ':' after field name");
+    const typeExpr = this.parseTypeExpr();
+    let initializer;
+    if (this.match("EQ")) {
+      initializer = this.parseExpression();
+    }
+    return {
+      kind: "stateField",
+      name: nameToken.lexeme,
+      typeExpr,
+      initializer,
+      location: mergeLocations(
+        nameToken.location,
+        initializer?.location ?? typeExpr.location
+      )
+    };
+  }
+  // ============ Computed ============
+  parseComputed() {
+    const start = this.consume("COMPUTED", "Expected 'computed'").location;
+    const name = this.consume("IDENTIFIER", "Expected computed name").lexeme;
+    this.consume("EQ", "Expected '=' after computed name");
+    const expression = this.parseExpression();
+    return {
+      kind: "computed",
+      name,
+      expression,
+      location: mergeLocations(start, expression.location)
+    };
+  }
+  // ============ Action ============
+  parseAction() {
+    const start = this.consume("ACTION", "Expected 'action'").location;
+    const name = this.consume("IDENTIFIER", "Expected action name").lexeme;
+    this.consume("LPAREN", "Expected '(' after action name");
+    const params = [];
+    if (!this.check("RPAREN")) {
+      do {
+        params.push(this.parseParam());
+      } while (this.match("COMMA"));
+    }
+    this.consume("RPAREN", "Expected ')' after parameters");
+    let available;
+    if (this.match("AVAILABLE")) {
+      this.consume("WHEN", "Expected 'when' after 'available'");
+      available = this.parseExpression();
+    }
+    this.consume("LBRACE", "Expected '{' to start action body");
+    const body = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      const stmt = this.parseGuardedStmt();
+      if (stmt) body.push(stmt);
+    }
+    const end = this.consume("RBRACE", "Expected '}' to close action").location;
+    return {
+      kind: "action",
+      name,
+      params,
+      available,
+      body,
+      location: mergeLocations(start, end)
+    };
+  }
+  parseParam() {
+    const nameToken = this.consume("IDENTIFIER", "Expected parameter name");
+    this.consume("COLON", "Expected ':' after parameter name");
+    const typeExpr = this.parseTypeExpr();
+    return {
+      kind: "param",
+      name: nameToken.lexeme,
+      typeExpr,
+      location: mergeLocations(nameToken.location, typeExpr.location)
+    };
+  }
+  // ============ Statements ============
+  parseGuardedStmt() {
+    if (this.check("WHEN")) return this.parseWhenStmt();
+    if (this.check("ONCE")) return this.parseOnceStmt();
+    if (this.isOnceIntentContext()) return this.parseOnceIntentStmt();
+    const token = this.peek();
+    if (token.kind === "PATCH" || token.lexeme === "patch" || token.kind === "EFFECT" || token.lexeme === "effect" || token.kind === "FAIL" || token.lexeme === "fail" || token.kind === "STOP" || token.lexeme === "stop") {
+      this.error(
+        `'${token.lexeme}' must be inside a guard block (when, once, or onceIntent). Wrap it: when true { ${token.lexeme} ... }`
+      );
+      this.skipToRecoveryPoint();
+      return null;
+    }
+    this.error(`Unexpected token '${token.lexeme}'. Expected 'when', 'once', or 'onceIntent'.`);
+    this.advance();
+    return null;
+  }
+  /**
+   * Skip tokens until we reach a recovery point (closing brace, guard keyword, or EOF).
+   */
+  skipToRecoveryPoint() {
+    let braceDepth = 0;
+    while (!this.isAtEnd()) {
+      const t = this.peek();
+      if (t.kind === "LBRACE") {
+        braceDepth++;
+        this.advance();
+        continue;
+      }
+      if (t.kind === "RBRACE") {
+        if (braceDepth === 0) return;
+        braceDepth--;
+        this.advance();
+        continue;
+      }
+      if (braceDepth === 0 && (t.kind === "WHEN" || t.kind === "ONCE" || t.lexeme === "onceIntent")) {
+        return;
+      }
+      this.advance();
+    }
+  }
+  parseWhenStmt() {
+    const start = this.consume("WHEN", "Expected 'when'").location;
+    const condition = this.parseExpression();
+    this.consume("LBRACE", "Expected '{' after when condition");
+    const body = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      const stmt = this.parseInnerStmt();
+      if (stmt) body.push(stmt);
+    }
+    const end = this.consume("RBRACE", "Expected '}' to close when block").location;
+    return {
+      kind: "when",
+      condition,
+      body,
+      location: mergeLocations(start, end)
+    };
+  }
+  parseOnceStmt() {
+    const start = this.consume("ONCE", "Expected 'once'").location;
+    this.consume("LPAREN", "Expected '(' after 'once'");
+    const marker = this.parsePath();
+    this.consume("RPAREN", "Expected ')' after marker");
+    let condition;
+    if (this.match("WHEN")) {
+      condition = this.parseExpression();
+    }
+    this.consume("LBRACE", "Expected '{' to start once block");
+    const body = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      const stmt = this.parseInnerStmt();
+      if (stmt) body.push(stmt);
+    }
+    const end = this.consume("RBRACE", "Expected '}' to close once block").location;
+    return {
+      kind: "once",
+      marker,
+      condition,
+      body,
+      location: mergeLocations(start, end)
+    };
+  }
+  parseOnceIntentStmt() {
+    const startToken = this.consume("IDENTIFIER", "Expected 'onceIntent'");
+    let condition;
+    if (this.match("WHEN")) {
+      condition = this.parseExpression();
+    }
+    this.consume("LBRACE", "Expected '{' to start onceIntent block");
+    const body = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      const stmt = this.parseInnerStmt();
+      if (stmt) body.push(stmt);
+    }
+    const end = this.consume("RBRACE", "Expected '}' to close onceIntent block").location;
+    return {
+      kind: "onceIntent",
+      condition,
+      body,
+      location: mergeLocations(startToken.location, end)
+    };
+  }
+  parseInnerStmt() {
+    if (this.check("PATCH")) return this.parsePatchStmt();
+    if (this.check("EFFECT")) return this.parseEffectStmt();
+    if (this.check("WHEN")) return this.parseWhenStmt();
+    if (this.check("ONCE")) return this.parseOnceStmt();
+    if (this.isOnceIntentContext()) return this.parseOnceIntentStmt();
+    if (this.check("FAIL")) return this.parseFailStmt();
+    if (this.check("STOP")) return this.parseStopStmt();
+    this.error(`Unexpected token '${this.peek().lexeme}'. Expected 'patch', 'effect', 'when', 'once', 'onceIntent', 'fail', or 'stop'.`);
+    this.advance();
+    return null;
+  }
+  parsePatchStmt() {
+    const start = this.consume("PATCH", "Expected 'patch'").location;
+    const path = this.parsePath();
+    let op;
+    let value;
+    let end;
+    if (this.match("UNSET")) {
+      op = "unset";
+      end = this.previous().location;
+    } else if (this.match("MERGE")) {
+      op = "merge";
+      value = this.parseExpression();
+      end = value.location;
+    } else {
+      this.consume("EQ", "Expected '=', 'unset', or 'merge' after path");
+      op = "set";
+      value = this.parseExpression();
+      end = value.location;
+    }
+    return {
+      kind: "patch",
+      path,
+      op,
+      value,
+      location: mergeLocations(start, end)
+    };
+  }
+  parseEffectStmt() {
+    const start = this.consume("EFFECT", "Expected 'effect'").location;
+    let effectType = this.consume("IDENTIFIER", "Expected effect type").lexeme;
+    while (this.match("DOT")) {
+      effectType += "." + this.consume("IDENTIFIER", "Expected identifier after '.'").lexeme;
+    }
+    this.consume("LPAREN", "Expected '(' after effect type");
+    this.consume("LBRACE", "Expected '{' for effect arguments");
+    const args = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      args.push(this.parseEffectArg());
+      this.match("COMMA");
+    }
+    this.consume("RBRACE", "Expected '}' after effect arguments");
+    const end = this.consume("RPAREN", "Expected ')' to close effect").location;
+    return {
+      kind: "effect",
+      effectType,
+      args,
+      location: mergeLocations(start, end)
+    };
+  }
+  parseEffectArg() {
+    const nameToken = this.match("IDENTIFIER", "FAIL") ? this.previous() : this.consume("IDENTIFIER", "Expected argument name");
+    this.consume("COLON", "Expected ':' after argument name");
+    const isPath = ["into", "pass", "fail"].includes(nameToken.lexeme);
+    const value = isPath ? this.parsePath() : this.parseExpression();
+    return {
+      kind: "effectArg",
+      name: nameToken.lexeme,
+      value,
+      isPath,
+      location: mergeLocations(nameToken.location, value.location)
+    };
+  }
+  /**
+   * v0.3.2: Parse fail statement
+   * FailStmt ::= 'fail' StringLiteral ('with' Expr)?
+   */
+  parseFailStmt() {
+    const start = this.consume("FAIL", "Expected 'fail'").location;
+    const codeToken = this.consume("STRING", "Expected error code string after 'fail'");
+    const code = codeToken.value;
+    let message;
+    let end = codeToken.location;
+    if (this.match("WITH")) {
+      message = this.parseExpression();
+      end = message.location;
+    }
+    return {
+      kind: "fail",
+      code,
+      message,
+      location: mergeLocations(start, end)
+    };
+  }
+  /**
+   * v0.3.2: Parse stop statement
+   * StopStmt ::= 'stop' StringLiteral
+   */
+  parseStopStmt() {
+    const start = this.consume("STOP", "Expected 'stop'").location;
+    const reasonToken = this.consume("STRING", "Expected reason string after 'stop'");
+    const reason = reasonToken.value;
+    return {
+      kind: "stop",
+      reason,
+      location: mergeLocations(start, reasonToken.location)
+    };
+  }
+  // ============ Types ============
+  parseTypeExpr() {
+    let type = this.parseBaseType();
+    if (this.check("PIPE")) {
+      const types = [type];
+      while (this.match("PIPE")) {
+        types.push(this.parseBaseType());
+      }
+      type = {
+        kind: "unionType",
+        types,
+        location: mergeLocations(types[0].location, types[types.length - 1].location)
+      };
+    }
+    return type;
+  }
+  parseBaseType() {
+    if (this.check("LBRACE")) {
+      return this.parseObjectType();
+    }
+    if (this.check("STRING")) {
+      const token = this.advance();
+      return {
+        kind: "literalType",
+        value: token.value,
+        location: token.location
+      };
+    }
+    if (this.check("NUMBER")) {
+      const token = this.advance();
+      return {
+        kind: "literalType",
+        value: token.value,
+        location: token.location
+      };
+    }
+    if (this.check("TRUE") || this.check("FALSE")) {
+      const token = this.advance();
+      return {
+        kind: "literalType",
+        value: token.kind === "TRUE",
+        location: token.location
+      };
+    }
+    if (this.check("NULL")) {
+      const token = this.advance();
+      return {
+        kind: "literalType",
+        value: null,
+        location: token.location
+      };
+    }
+    const nameToken = this.consume("IDENTIFIER", "Expected type name");
+    if (this.match("LT")) {
+      if (nameToken.lexeme === "Array") {
+        const elementType = this.parseTypeExpr();
+        const end = this.consume("GT", "Expected '>' after array element type").location;
+        return {
+          kind: "arrayType",
+          elementType,
+          location: mergeLocations(nameToken.location, end)
+        };
+      } else if (nameToken.lexeme === "Record") {
+        const keyType = this.parseTypeExpr();
+        this.consume("COMMA", "Expected ',' between Record type parameters");
+        const valueType = this.parseTypeExpr();
+        const end = this.consume("GT", "Expected '>' after Record value type").location;
+        return {
+          kind: "recordType",
+          keyType,
+          valueType,
+          location: mergeLocations(nameToken.location, end)
+        };
+      } else {
+        this.error(`Unknown generic type '${nameToken.lexeme}'`);
+        while (!this.check("GT") && !this.isAtEnd()) this.advance();
+        this.match("GT");
+      }
+    }
+    return {
+      kind: "simpleType",
+      name: nameToken.lexeme,
+      location: nameToken.location
+    };
+  }
+  /**
+   * v0.3.3: Parse object type
+   * Syntax: { field: Type, field?: Type, ... }
+   */
+  parseObjectType() {
+    const start = this.consume("LBRACE", "Expected '{'").location;
+    const fields = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      const nameToken = this.consume("IDENTIFIER", "Expected field name");
+      const optional = this.match("QUESTION");
+      this.consume("COLON", "Expected ':' after field name");
+      const typeExpr = this.parseTypeExpr();
+      fields.push({
+        kind: "typeField",
+        name: nameToken.lexeme,
+        typeExpr,
+        optional,
+        location: mergeLocations(nameToken.location, typeExpr.location)
+      });
+      this.match("COMMA");
+    }
+    const end = this.consume("RBRACE", "Expected '}' to close object type").location;
+    return {
+      kind: "objectType",
+      fields,
+      location: mergeLocations(start, end)
+    };
+  }
+  // ============ Expressions (Pratt Parser) ============
+  parseExpression(minPrecedence = 0 /* NONE */) {
+    let left = this.parsePrimary();
+    while (true) {
+      const precedence = getBinaryPrecedence(this.peek().kind);
+      if (precedence <= minPrecedence) break;
+      if (this.peek().kind === "QUESTION") {
+        left = this.parseTernary(left);
+        continue;
+      }
+      const op = tokenToBinaryOp(this.peek().kind);
+      if (!op) break;
+      this.advance();
+      const nextPrecedence = isRightAssociative(this.previous().kind) ? precedence - 1 : precedence;
+      const right = this.parseExpression(nextPrecedence);
+      left = {
+        kind: "binary",
+        operator: op,
+        left,
+        right,
+        location: mergeLocations(left.location, right.location)
+      };
+    }
+    return left;
+  }
+  parseTernary(condition) {
+    this.consume("QUESTION", "Expected '?'");
+    const consequent = this.parseExpression();
+    this.consume("COLON", "Expected ':' in ternary expression");
+    const alternate = this.parseExpression(1 /* TERNARY */ - 1);
+    return {
+      kind: "ternary",
+      condition,
+      consequent,
+      alternate,
+      location: mergeLocations(condition.location, alternate.location)
+    };
+  }
+  parsePrimary() {
+    if (this.check("BANG") || this.check("MINUS") && this.isUnaryContext()) {
+      const op = this.advance();
+      const operand = this.parsePrimary();
+      return {
+        kind: "unary",
+        operator: op.kind === "BANG" ? "!" : "-",
+        operand,
+        location: mergeLocations(op.location, operand.location)
+      };
+    }
+    if (this.match("LPAREN")) {
+      const expr = this.parseExpression();
+      this.consume("RPAREN", "Expected ')' after expression");
+      return expr;
+    }
+    if (this.check("LBRACE")) {
+      return this.parseObjectLiteral();
+    }
+    if (this.check("LBRACKET")) {
+      return this.parseArrayLiteral();
+    }
+    if (this.check("NUMBER")) {
+      const token = this.advance();
+      return {
+        kind: "literal",
+        value: token.value,
+        literalType: "number",
+        location: token.location
+      };
+    }
+    if (this.check("STRING")) {
+      const token = this.advance();
+      return {
+        kind: "literal",
+        value: token.value,
+        literalType: "string",
+        location: token.location
+      };
+    }
+    if (this.check("TRUE") || this.check("FALSE")) {
+      const token = this.advance();
+      return {
+        kind: "literal",
+        value: token.kind === "TRUE",
+        literalType: "boolean",
+        location: token.location
+      };
+    }
+    if (this.check("NULL")) {
+      const token = this.advance();
+      return {
+        kind: "literal",
+        value: null,
+        literalType: "null",
+        location: token.location
+      };
+    }
+    if (this.check("SYSTEM_IDENT")) {
+      const token = this.advance();
+      const path = token.lexeme.slice(1).split(".");
+      return this.parsePostfix({
+        kind: "systemIdent",
+        path,
+        location: token.location
+      });
+    }
+    if (this.check("ITEM")) {
+      const token = this.advance();
+      return this.parsePostfix({
+        kind: "iterationVar",
+        name: "item",
+        location: token.location
+      });
+    }
+    if (this.check("MERGE") && this.peekNext()?.kind === "LPAREN") {
+      const token = this.advance();
+      return this.parseFunctionCall(token);
+    }
+    if (this.check("IDENTIFIER")) {
+      const token = this.advance();
+      if (this.check("LPAREN")) {
+        return this.parseFunctionCall(token);
+      }
+      return this.parsePostfix({
+        kind: "identifier",
+        name: token.lexeme,
+        location: token.location
+      });
+    }
+    this.error(`Unexpected token '${this.peek().lexeme}'`);
+    return {
+      kind: "literal",
+      value: null,
+      literalType: "null",
+      location: this.peek().location
+    };
+  }
+  parseFunctionCall(nameToken) {
+    this.consume("LPAREN", "Expected '(' for function call");
+    const args = [];
+    if (!this.check("RPAREN")) {
+      do {
+        args.push(this.parseExpression());
+      } while (this.match("COMMA"));
+    }
+    const end = this.consume("RPAREN", "Expected ')' after arguments").location;
+    return this.parsePostfix({
+      kind: "functionCall",
+      name: nameToken.lexeme,
+      args,
+      location: mergeLocations(nameToken.location, end)
+    });
+  }
+  parsePostfix(expr) {
+    while (true) {
+      if (this.match("DOT")) {
+        const prop = this.consume("IDENTIFIER", "Expected property name after '.'");
+        expr = {
+          kind: "propertyAccess",
+          object: expr,
+          property: prop.lexeme,
+          location: mergeLocations(expr.location, prop.location)
+        };
+      } else if (this.match("LBRACKET")) {
+        const index = this.parseExpression();
+        const end = this.consume("RBRACKET", "Expected ']' after index").location;
+        expr = {
+          kind: "indexAccess",
+          object: expr,
+          index,
+          location: mergeLocations(expr.location, end)
+        };
+      } else {
+        break;
+      }
+    }
+    return expr;
+  }
+  parseObjectLiteral() {
+    const start = this.consume("LBRACE", "Expected '{'").location;
+    const properties = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      const keyToken = this.consume("IDENTIFIER", "Expected property name");
+      this.consume("COLON", "Expected ':' after property name");
+      const value = this.parseExpression();
+      properties.push({
+        kind: "objectProperty",
+        key: keyToken.lexeme,
+        value,
+        location: mergeLocations(keyToken.location, value.location)
+      });
+      if (!this.check("RBRACE")) {
+        this.consume("COMMA", "Expected ',' between properties");
+      }
+    }
+    const end = this.consume("RBRACE", "Expected '}' to close object").location;
+    return {
+      kind: "objectLiteral",
+      properties,
+      location: mergeLocations(start, end)
+    };
+  }
+  parseArrayLiteral() {
+    const start = this.consume("LBRACKET", "Expected '['").location;
+    const elements = [];
+    while (!this.check("RBRACKET") && !this.isAtEnd()) {
+      elements.push(this.parseExpression());
+      if (!this.check("RBRACKET")) {
+        this.consume("COMMA", "Expected ',' between elements");
+      }
+    }
+    const end = this.consume("RBRACKET", "Expected ']' to close array").location;
+    return {
+      kind: "arrayLiteral",
+      elements,
+      location: mergeLocations(start, end)
+    };
+  }
+  // ============ Path ============
+  parsePath() {
+    const segments = [];
+    const start = this.peek().location;
+    const first = this.consume("IDENTIFIER", "Expected identifier");
+    segments.push({
+      kind: "propertySegment",
+      name: first.lexeme,
+      location: first.location
+    });
+    while (true) {
+      if (this.match("DOT")) {
+        const prop = this.consume("IDENTIFIER", "Expected property name");
+        segments.push({
+          kind: "propertySegment",
+          name: prop.lexeme,
+          location: prop.location
+        });
+      } else if (this.match("LBRACKET")) {
+        const index = this.parseExpression();
+        const end = this.consume("RBRACKET", "Expected ']'").location;
+        segments.push({
+          kind: "indexSegment",
+          index,
+          location: mergeLocations(index.location, end)
+        });
+      } else {
+        break;
+      }
+    }
+    const last = segments[segments.length - 1];
+    return {
+      kind: "path",
+      segments,
+      location: mergeLocations(start, last.location)
+    };
+  }
+  // ============ Helpers ============
+  isUnaryContext() {
+    if (this.current === 0) return true;
+    const prev = this.previous();
+    const unaryPrecedingTokens = [
+      "LPAREN",
+      "LBRACKET",
+      "LBRACE",
+      "COMMA",
+      "COLON",
+      "EQ",
+      "PLUS",
+      "MINUS",
+      "STAR",
+      "SLASH",
+      "PERCENT",
+      "EQ_EQ",
+      "BANG_EQ",
+      "LT",
+      "LT_EQ",
+      "GT",
+      "GT_EQ",
+      "AMP_AMP",
+      "PIPE_PIPE",
+      "BANG",
+      "QUESTION",
+      "QUESTION_QUESTION"
+    ];
+    return unaryPrecedingTokens.includes(prev.kind);
+  }
+  peek() {
+    return this.tokens[this.current];
+  }
+  peekNext() {
+    if (this.current + 1 >= this.tokens.length) {
+      return this.tokens[this.tokens.length - 1];
+    }
+    return this.tokens[this.current + 1];
+  }
+  previous() {
+    return this.tokens[this.current - 1];
+  }
+  isAtEnd() {
+    return this.peek().kind === "EOF";
+  }
+  advance() {
+    if (!this.isAtEnd()) this.current++;
+    return this.previous();
+  }
+  check(kind) {
+    if (this.isAtEnd()) return false;
+    return this.peek().kind === kind;
+  }
+  isOnceIntentContext() {
+    if (!this.check("IDENTIFIER")) return false;
+    const token = this.peek();
+    if (token.lexeme !== "onceIntent") return false;
+    const next = this.peekNext();
+    return next.kind === "LBRACE" || next.kind === "WHEN";
+  }
+  match(...kinds) {
+    for (const kind of kinds) {
+      if (this.check(kind)) {
+        this.advance();
+        return true;
+      }
+    }
+    return false;
+  }
+  consume(kind, message) {
+    if (this.check(kind)) return this.advance();
+    throw this.errorAtCurrent(message);
+  }
+  error(message) {
+    this.diagnostics.push({
+      severity: "error",
+      code: "MEL_PARSER",
+      message,
+      location: this.previous().location
+    });
+  }
+  errorAtCurrent(message) {
+    this.diagnostics.push({
+      severity: "error",
+      code: "MEL_PARSER",
+      message,
+      location: this.peek().location
+    });
+    return new Error(message);
+  }
+};
+function parse(tokens) {
+  const parser = new Parser(tokens);
+  return parser.parse();
+}
+
+// src/analyzer/scope.ts
+var Scope = class {
+  parent;
+  symbols = /* @__PURE__ */ new Map();
+  kind;
+  constructor(kind, parent = null) {
+    this.kind = kind;
+    this.parent = parent;
+  }
+  /**
+   * Define a new symbol in this scope
+   */
+  define(symbol) {
+    this.symbols.set(symbol.name, symbol);
+  }
+  /**
+   * Look up a symbol, searching parent scopes if not found
+   */
+  lookup(name) {
+    const symbol = this.symbols.get(name);
+    if (symbol) return symbol;
+    return this.parent?.lookup(name);
+  }
+  /**
+   * Check if a symbol is defined in this scope (not parent scopes)
+   */
+  isDefined(name) {
+    return this.symbols.has(name);
+  }
+};
+var ScopeAnalyzer = class {
+  diagnostics = [];
+  scopes = /* @__PURE__ */ new Map();
+  currentScope = null;
+  domainScope = null;
+  /**
+   * Analyze a MEL program
+   */
+  analyze(program) {
+    this.diagnostics = [];
+    this.scopes = /* @__PURE__ */ new Map();
+    this.currentScope = null;
+    this.domainScope = null;
+    this.analyzeDomain(program.domain);
+    return {
+      scopes: this.scopes,
+      diagnostics: this.diagnostics
+    };
+  }
+  analyzeDomain(domain) {
+    const scope = new Scope("domain");
+    this.domainScope = scope;
+    this.currentScope = scope;
+    this.scopes.set("domain", scope);
+    for (const member of domain.members) {
+      if (member.kind === "state") {
+        for (const field of member.fields) {
+          this.defineSymbol({
+            name: field.name,
+            kind: "state",
+            location: field.location
+          });
+        }
+      } else if (member.kind === "computed") {
+        this.defineSymbol({
+          name: member.name,
+          kind: "computed",
+          location: member.location
+        });
+      } else if (member.kind === "action") {
+        this.defineSymbol({
+          name: member.name,
+          kind: "action",
+          location: member.location
+        });
+      }
+    }
+    for (const member of domain.members) {
+      if (member.kind === "computed") {
+        this.analyzeComputedExpr(member);
+      } else if (member.kind === "action") {
+        this.analyzeAction(member);
+      }
+    }
+  }
+  analyzeComputedExpr(computed) {
+    this.analyzeExpr(computed.expression, "computed");
+  }
+  analyzeAction(action) {
+    const scope = new Scope("action", this.domainScope);
+    this.currentScope = scope;
+    this.scopes.set(`action.${action.name}`, scope);
+    for (const param of action.params) {
+      scope.define({
+        name: param.name,
+        kind: "param",
+        location: param.location
+      });
+    }
+    for (const stmt of action.body) {
+      this.analyzeStmt(stmt);
+    }
+    this.currentScope = this.domainScope;
+  }
+  analyzeStmt(stmt) {
+    switch (stmt.kind) {
+      case "when":
+        this.analyzeExpr(stmt.condition, "action");
+        for (const inner of stmt.body) {
+          this.analyzeStmt(inner);
+        }
+        break;
+      case "onceIntent":
+        if (stmt.condition) {
+          this.analyzeExpr(stmt.condition, "action");
+        }
+        for (const inner of stmt.body) {
+          this.analyzeStmt(inner);
+        }
+        break;
+      case "once":
+        this.validatePath(stmt.marker);
+        if (stmt.condition) {
+          this.analyzeExpr(stmt.condition, "action");
+        }
+        for (const inner of stmt.body) {
+          this.analyzeStmt(inner);
+        }
+        break;
+      case "patch":
+        this.validatePath(stmt.path);
+        if (stmt.value) {
+          this.analyzeExpr(stmt.value, "action");
+        }
+        break;
+      case "effect":
+        for (const arg of stmt.args) {
+          if (arg.isPath) {
+            this.validatePath(arg.value);
+          } else {
+            this.analyzeExpr(arg.value, "action");
+          }
+        }
+        break;
+    }
+  }
+  analyzeExpr(expr, context) {
+    switch (expr.kind) {
+      case "identifier":
+        this.checkIdentifier(expr.name, expr.location, context);
+        break;
+      case "systemIdent":
+        this.checkSystemIdent(expr.path, expr.location, context);
+        break;
+      case "propertyAccess":
+        this.analyzeExpr(expr.object, context);
+        break;
+      case "indexAccess":
+        this.analyzeExpr(expr.object, context);
+        this.analyzeExpr(expr.index, context);
+        break;
+      case "functionCall":
+        for (const arg of expr.args) {
+          this.analyzeExpr(arg, context);
+        }
+        break;
+      case "binary":
+        this.analyzeExpr(expr.left, context);
+        this.analyzeExpr(expr.right, context);
+        break;
+      case "unary":
+        this.analyzeExpr(expr.operand, context);
+        break;
+      case "ternary":
+        this.analyzeExpr(expr.condition, context);
+        this.analyzeExpr(expr.consequent, context);
+        this.analyzeExpr(expr.alternate, context);
+        break;
+      case "objectLiteral":
+        for (const prop of expr.properties) {
+          this.analyzeExpr(prop.value, context);
+        }
+        break;
+      case "arrayLiteral":
+        for (const elem of expr.elements) {
+          this.analyzeExpr(elem, context);
+        }
+        break;
+      case "iterationVar":
+        break;
+      case "literal":
+        break;
+    }
+  }
+  checkIdentifier(name, location, context) {
+    const symbol = this.currentScope?.lookup(name);
+    if (!symbol) {
+      this.error(`Undefined identifier '${name}'`, location, "E_UNDEFINED");
+      return;
+    }
+    if (context === "computed") {
+      if (symbol.kind === "param") {
+        this.error(
+          `Cannot access parameter '${name}' in computed expression`,
+          location,
+          "E_INVALID_ACCESS"
+        );
+      }
+    }
+  }
+  checkSystemIdent(path, location, context) {
+    const [namespace, ...rest] = path;
+    if (namespace === "system" && context === "computed") {
+      this.error(
+        `Cannot use $system.* in computed expressions (non-deterministic)`,
+        location,
+        "E001"
+      );
+    }
+    if (namespace === "system") {
+      const validKeys = ["uuid", "timestamp", "time.now", "random"];
+      const key = rest.join(".");
+      if (key && !validKeys.includes(key)) {
+        this.error(
+          `Invalid system value '$system.${key}'. Valid values: ${validKeys.join(", ")}`,
+          location,
+          "E003"
+        );
+      }
+    }
+    if (namespace === "meta") {
+      const validKeys = ["intentId", "actionName", "timestamp"];
+      const key = rest.join(".");
+      if (key && !validKeys.includes(key)) {
+        this.error(
+          `Invalid meta value '$meta.${key}'. Valid values: ${validKeys.join(", ")}`,
+          location,
+          "E003"
+        );
+      }
+    }
+  }
+  validatePath(path) {
+    if (!path || !path.segments) return;
+    const first = path.segments[0];
+    if (first?.kind === "propertySegment") {
+      const symbol = this.currentScope?.lookup(first.name);
+      if (!symbol) {
+        this.error(
+          `Undefined identifier '${first.name}' in path`,
+          path.location,
+          "E_UNDEFINED"
+        );
+      }
+    }
+  }
+  defineSymbol(symbol) {
+    if (!this.currentScope) return;
+    if (this.currentScope.isDefined(symbol.name)) {
+      this.error(
+        `Duplicate identifier '${symbol.name}'`,
+        symbol.location,
+        "E_DUPLICATE"
+      );
+      return;
+    }
+    this.currentScope.define(symbol);
+  }
+  error(message, location, code) {
+    this.diagnostics.push({
+      severity: "error",
+      code,
+      message,
+      location
+    });
+  }
+};
+function analyzeScope(program) {
+  const analyzer = new ScopeAnalyzer();
+  return analyzer.analyze(program);
+}
+
+// src/diagnostics/types.ts
+function createError(code, message, location, options) {
+  return {
+    severity: "error",
+    code,
+    message,
+    location,
+    ...options
+  };
+}
+function createWarning(code, message, location, options) {
+  return {
+    severity: "warning",
+    code,
+    message,
+    location,
+    ...options
+  };
+}
+function createInfo(code, message, location) {
+  return {
+    severity: "info",
+    code,
+    message,
+    location
+  };
+}
+function isError(diagnostic) {
+  return diagnostic.severity === "error";
+}
+function hasErrors(diagnostics) {
+  return diagnostics.some(isError);
+}
+function filterBySeverity(diagnostics, severity) {
+  return diagnostics.filter((d) => d.severity === severity);
+}
+
+// src/analyzer/validator.ts
+function createContext() {
+  return {
+    inAction: false,
+    inGuard: false,
+    guardDepth: 0,
+    hasMarkerPatch: false,
+    diagnostics: []
+  };
+}
+var SemanticValidator = class {
+  ctx = createContext();
+  /**
+   * Validate a MEL program
+   */
+  validate(program) {
+    this.ctx = createContext();
+    this.validateDomain(program.domain);
+    return {
+      valid: !this.ctx.diagnostics.some((d) => d.severity === "error"),
+      diagnostics: this.ctx.diagnostics
+    };
+  }
+  validateDomain(domain) {
+    if (domain.name.startsWith("__")) {
+      this.error(
+        "Domain name cannot start with '__' (reserved prefix)",
+        domain.location,
+        "E_RESERVED_NAME"
+      );
+    }
+    for (const member of domain.members) {
+      switch (member.kind) {
+        case "state":
+          this.validateState(member);
+          break;
+        case "computed":
+          this.validateExpr(member.expression, "computed");
+          break;
+        case "action":
+          this.validateAction(member);
+          break;
+      }
+    }
+  }
+  /**
+   * v0.3.3: Validate state fields for W012 (anonymous object types)
+   */
+  validateState(state) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const field of state.fields) {
+      const prev = seen.get(field.name);
+      if (prev) {
+        this.error(
+          `Duplicate state field '${field.name}'. First declared at line ${prev.start.line}`,
+          field.location,
+          "E_DUPLICATE_FIELD"
+        );
+      } else {
+        seen.set(field.name, field.location);
+      }
+      this.validateStateField(field);
+    }
+  }
+  /**
+   * v0.3.3: Validate state field - check for anonymous object types (W012)
+   */
+  validateStateField(field) {
+    this.checkAnonymousObjectType(field.typeExpr, field.location);
+  }
+  /**
+   * v0.3.3: Check if a type expression contains anonymous object types
+   * Issues W012 warning for inline object types in state fields
+   */
+  checkAnonymousObjectType(typeExpr, fieldLocation) {
+    switch (typeExpr.kind) {
+      case "objectType":
+        this.ctx.diagnostics.push(
+          createWarning(
+            "W012",
+            "Anonymous object type in state field. Use a named type declaration instead: type MyType = { ... }",
+            typeExpr.location,
+            {
+              suggestion: "Define this type using 'type TypeName = { ... }' and reference it by name"
+            }
+          )
+        );
+        for (const f of typeExpr.fields) {
+          this.checkAnonymousObjectType(f.typeExpr, fieldLocation);
+        }
+        break;
+      case "arrayType":
+        this.checkAnonymousObjectType(typeExpr.elementType, fieldLocation);
+        break;
+      case "recordType":
+        this.checkAnonymousObjectType(typeExpr.keyType, fieldLocation);
+        this.checkAnonymousObjectType(typeExpr.valueType, fieldLocation);
+        break;
+      case "unionType":
+        for (const t of typeExpr.types) {
+          this.checkAnonymousObjectType(t, fieldLocation);
+        }
+        break;
+    }
+  }
+  validateAction(action) {
+    this.ctx.inAction = true;
+    if (action.available) {
+      this.validateAvailableExpr(action.available);
+    }
+    for (const stmt of action.body) {
+      this.validateGuardedStmt(stmt);
+    }
+    this.ctx.inAction = false;
+  }
+  /**
+   * v0.3.3: Validate available expression is pure (E005)
+   * No $system.*, no effects, no $input.*
+   */
+  validateAvailableExpr(expr) {
+    switch (expr.kind) {
+      case "systemIdent":
+        if (expr.path[0] === "system") {
+          this.error(
+            "$system.* cannot be used in available condition (must be pure expression)",
+            expr.location,
+            "E005"
+          );
+        }
+        if (expr.path[0] === "input") {
+          this.error(
+            "$input.* cannot be used in available condition (parameters not available at availability check)",
+            expr.location,
+            "E005"
+          );
+        }
+        break;
+      case "functionCall":
+        for (const arg of expr.args) {
+          this.validateAvailableExpr(arg);
+        }
+        break;
+      case "binary":
+        this.validateAvailableExpr(expr.left);
+        this.validateAvailableExpr(expr.right);
+        break;
+      case "unary":
+        this.validateAvailableExpr(expr.operand);
+        break;
+      case "ternary":
+        this.validateAvailableExpr(expr.condition);
+        this.validateAvailableExpr(expr.consequent);
+        this.validateAvailableExpr(expr.alternate);
+        break;
+      case "propertyAccess":
+        this.validateAvailableExpr(expr.object);
+        break;
+      case "indexAccess":
+        this.validateAvailableExpr(expr.object);
+        this.validateAvailableExpr(expr.index);
+        break;
+      case "objectLiteral":
+        for (const prop of expr.properties) {
+          this.validateAvailableExpr(prop.value);
+        }
+        break;
+      case "arrayLiteral":
+        for (const elem of expr.elements) {
+          this.validateAvailableExpr(elem);
+        }
+        break;
+    }
+  }
+  validateGuardedStmt(stmt) {
+    switch (stmt.kind) {
+      case "when":
+        this.validateWhen(stmt);
+        break;
+      case "once":
+        this.validateOnce(stmt);
+        break;
+      case "onceIntent":
+        this.validateOnceIntent(stmt);
+        break;
+      case "patch":
+        this.validatePatch(stmt);
+        break;
+      case "effect":
+        this.validateEffect(stmt);
+        break;
+    }
+  }
+  validateWhen(stmt) {
+    this.ctx.inGuard = true;
+    this.ctx.guardDepth++;
+    this.validateCondition(stmt.condition, "when");
+    for (const inner of stmt.body) {
+      this.validateGuardedStmt(inner);
+    }
+    this.ctx.guardDepth--;
+    if (this.ctx.guardDepth === 0) {
+      this.ctx.inGuard = false;
+    }
+  }
+  validateOnce(stmt) {
+    this.ctx.inGuard = true;
+    this.ctx.guardDepth++;
+    this.ctx.hasMarkerPatch = false;
+    if (stmt.condition) {
+      this.validateCondition(stmt.condition, "once");
+    }
+    for (const inner of stmt.body) {
+      this.validateGuardedStmt(inner);
+    }
+    this.ctx.guardDepth--;
+    if (this.ctx.guardDepth === 0) {
+      this.ctx.inGuard = false;
+    }
+  }
+  validateOnceIntent(stmt) {
+    this.ctx.inGuard = true;
+    this.ctx.guardDepth++;
+    if (stmt.condition) {
+      this.validateCondition(stmt.condition, "onceIntent");
+    }
+    for (const inner of stmt.body) {
+      this.validateGuardedStmt(inner);
+    }
+    this.ctx.guardDepth--;
+    if (this.ctx.guardDepth === 0) {
+      this.ctx.inGuard = false;
+    }
+  }
+  validatePatch(stmt) {
+    if (!this.ctx.inGuard) {
+      this.error(
+        "Patch must be inside a guard (when, once, or onceIntent)",
+        stmt.location,
+        "E_UNGUARDED_PATCH"
+      );
+    }
+    if (stmt.value) {
+      this.validateExpr(stmt.value, "action");
+    }
+  }
+  validateEffect(stmt) {
+    if (!this.ctx.inGuard) {
+      this.error(
+        "Effect must be inside a guard (when, once, or onceIntent)",
+        stmt.location,
+        "E_UNGUARDED_EFFECT"
+      );
+    }
+    for (const arg of stmt.args) {
+      if (!arg.isPath) {
+        this.validateExpr(arg.value, "action");
+      }
+    }
+  }
+  validateCondition(expr, guardType) {
+    this.validateExpr(expr, "action");
+    if (expr.kind === "literal" && typeof expr.value !== "boolean") {
+      this.warn(
+        `Condition in ${guardType} is a non-boolean literal. Consider using a boolean expression`,
+        expr.location,
+        "W_NON_BOOL_COND"
+      );
+    }
+  }
+  validateExpr(expr, context) {
+    switch (expr.kind) {
+      case "functionCall":
+        this.validateFunctionCall(expr, context);
+        break;
+      case "binary":
+        this.validateExpr(expr.left, context);
+        this.validateExpr(expr.right, context);
+        break;
+      case "unary":
+        this.validateExpr(expr.operand, context);
+        break;
+      case "ternary":
+        this.validateExpr(expr.condition, context);
+        this.validateExpr(expr.consequent, context);
+        this.validateExpr(expr.alternate, context);
+        break;
+      case "propertyAccess":
+        this.validateExpr(expr.object, context);
+        break;
+      case "indexAccess":
+        this.validateExpr(expr.object, context);
+        this.validateExpr(expr.index, context);
+        break;
+      case "objectLiteral":
+        for (const prop of expr.properties) {
+          this.validateExpr(prop.value, context);
+        }
+        break;
+      case "arrayLiteral":
+        for (const elem of expr.elements) {
+          this.validateExpr(elem, context);
+        }
+        break;
+      case "systemIdent":
+        break;
+    }
+  }
+  validateFunctionCall(expr, context) {
+    const { name, args, location } = expr;
+    if (["reduce", "fold", "foldl", "foldr", "scan"].includes(name)) {
+      this.error(
+        `Function '${name}' is forbidden. Use sum(), min(), max() for aggregation instead`,
+        location,
+        "E011"
+      );
+    }
+    if (["sum", "min", "max"].includes(name) && args.length === 1) {
+      if (context === "action") {
+        this.error(
+          `Primitive aggregation '${name}()' can only be used in computed expressions, not in actions`,
+          location,
+          "E009"
+        );
+      }
+      const arg = args[0];
+      if (arg.kind === "functionCall") {
+        this.error(
+          `Primitive aggregation '${name}()' does not allow composition. Use a direct reference, not '${arg.name}()'`,
+          location,
+          "E010"
+        );
+      }
+    }
+    switch (name) {
+      // FDR-MEL-042: eq/neq on primitives only
+      case "eq":
+      case "neq":
+        break;
+      // FDR-MEL-026: len() on Array only
+      case "len":
+      // v0.3.3: sum() for array aggregation
+      case "sum":
+        if (args.length !== 1) {
+          this.error(
+            `Function '${name}' expects 1 argument, got ${args.length}`,
+            location,
+            "E_ARG_COUNT"
+          );
+        }
+        break;
+      // Binary functions need exactly 2 args
+      case "add":
+      case "sub":
+      case "mul":
+      case "div":
+      case "mod":
+      case "gt":
+      case "gte":
+      case "lt":
+      case "lte":
+        if (args.length !== 2) {
+          this.error(
+            `Function '${name}' expects 2 arguments, got ${args.length}`,
+            location,
+            "E_ARG_COUNT"
+          );
+        }
+        break;
+      // Unary functions need exactly 1 arg
+      case "not":
+      case "neg":
+      case "abs":
+      case "floor":
+      case "ceil":
+      case "round":
+      case "sqrt":
+      case "isNull":
+      case "isNotNull":
+      case "trim":
+      case "lower":
+      case "upper":
+      case "strlen":
+      case "keys":
+      case "values":
+      case "entries":
+      case "first":
+      case "last":
+      case "typeof":
+      case "toString":
+      case "toNumber":
+      case "toBoolean":
+      case "reverse":
+      case "unique":
+      case "flat":
+      case "fromEntries":
+        if (args.length !== 1) {
+          this.error(
+            `Function '${name}' expects 1 argument, got ${args.length}`,
+            location,
+            "E_ARG_COUNT"
+          );
+        }
+        break;
+      // Binary functions need exactly 2 args
+      case "pow":
+      case "filter":
+      case "map":
+      case "find":
+      case "every":
+      case "some":
+      case "at":
+      case "includes":
+      case "field":
+      case "hasKey":
+      case "pick":
+      case "omit":
+      case "startsWith":
+      case "endsWith":
+      case "strIncludes":
+      case "indexOf":
+        if (args.length !== 2) {
+          this.error(
+            `Function '${name}' expects 2 arguments, got ${args.length}`,
+            location,
+            "E_ARG_COUNT"
+          );
+        }
+        break;
+      // 2-3 arg functions
+      case "slice":
+      case "substring":
+      case "substr":
+      case "replace":
+        if (args.length < 2 || args.length > 3) {
+          this.error(
+            `Function '${name}' expects 2-3 arguments, got ${args.length}`,
+            location,
+            "E_ARG_COUNT"
+          );
+        }
+        break;
+      // split(str, delimiter)
+      case "split":
+        if (args.length !== 2) {
+          this.error(
+            `Function '${name}' expects 2 arguments, got ${args.length}`,
+            location,
+            "E_ARG_COUNT"
+          );
+        }
+        break;
+      // Variadic functions (at least 1 arg)
+      case "and":
+      case "or":
+      case "concat":
+      case "min":
+      case "max":
+      case "merge":
+      case "coalesce":
+      case "append":
+        if (args.length < 1) {
+          this.error(
+            `Function '${name}' expects at least 1 argument`,
+            location,
+            "E_ARG_COUNT"
+          );
+        }
+        break;
+      // Conditional needs exactly 3 args
+      case "if":
+      case "cond":
+        if (args.length !== 3) {
+          this.error(
+            `Function '${name}' expects 3 arguments, got ${args.length}`,
+            location,
+            "E_ARG_COUNT"
+          );
+        }
+        break;
+      default:
+        this.error(
+          `Unknown function '${name}'. Check spelling or see MEL builtin function reference`,
+          location,
+          "E_UNKNOWN_FN"
+        );
+        break;
+    }
+    for (const arg of args) {
+      this.validateExpr(arg, context);
+    }
+  }
+  error(message, location, code) {
+    this.ctx.diagnostics.push({
+      severity: "error",
+      code,
+      message,
+      location
+    });
+  }
+  warn(message, location, code) {
+    this.ctx.diagnostics.push({
+      severity: "warning",
+      code,
+      message,
+      location
+    });
+  }
+};
+function validateSemantics(program) {
+  const validator = new SemanticValidator();
+  return validator.validate(program);
+}
+
+// src/generator/normalizer.ts
+function normalizeExpr(op, left, right) {
+  switch (op) {
+    // Arithmetic
+    case "+":
+      return { kind: "add", left, right };
+    case "-":
+      return { kind: "sub", left, right };
+    case "*":
+      return { kind: "mul", left, right };
+    case "/":
+      return { kind: "div", left, right };
+    case "%":
+      return { kind: "mod", left, right };
+    // Comparison
+    case "==":
+      return { kind: "eq", left, right };
+    case "!=":
+      return { kind: "neq", left, right };
+    case "<":
+      return { kind: "lt", left, right };
+    case "<=":
+      return { kind: "lte", left, right };
+    case ">":
+      return { kind: "gt", left, right };
+    case ">=":
+      return { kind: "gte", left, right };
+    // Logical
+    case "&&":
+      return { kind: "and", args: [left, right] };
+    case "||":
+      return { kind: "or", args: [left, right] };
+    // Nullish coalescing
+    case "??":
+      return { kind: "coalesce", args: [left, right] };
+  }
+}
+function normalizeFunctionCall(name, args) {
+  switch (name) {
+    // ============ Arithmetic ============
+    case "add":
+      return { kind: "add", left: args[0], right: args[1] };
+    case "sub":
+      return { kind: "sub", left: args[0], right: args[1] };
+    case "mul":
+      return { kind: "mul", left: args[0], right: args[1] };
+    case "div":
+      return { kind: "div", left: args[0], right: args[1] };
+    case "mod":
+      return { kind: "mod", left: args[0], right: args[1] };
+    case "neg":
+      return { kind: "neg", arg: args[0] };
+    case "abs":
+      return { kind: "abs", arg: args[0] };
+    case "min":
+      if (args.length === 1) {
+        return { kind: "minArray", array: args[0] };
+      }
+      return { kind: "min", args };
+    case "max":
+      if (args.length === 1) {
+        return { kind: "maxArray", array: args[0] };
+      }
+      return { kind: "max", args };
+    // v0.3.2: sum array aggregation
+    case "sum":
+      return { kind: "sumArray", array: args[0] };
+    case "floor":
+      return { kind: "floor", arg: args[0] };
+    case "ceil":
+      return { kind: "ceil", arg: args[0] };
+    case "round":
+      return { kind: "round", arg: args[0] };
+    case "sqrt":
+      return { kind: "sqrt", arg: args[0] };
+    case "pow":
+      return { kind: "pow", base: args[0], exponent: args[1] };
+    // ============ Comparison ============
+    case "eq":
+      return { kind: "eq", left: args[0], right: args[1] };
+    case "neq":
+      return { kind: "neq", left: args[0], right: args[1] };
+    case "gt":
+      return { kind: "gt", left: args[0], right: args[1] };
+    case "gte":
+      return { kind: "gte", left: args[0], right: args[1] };
+    case "lt":
+      return { kind: "lt", left: args[0], right: args[1] };
+    case "lte":
+      return { kind: "lte", left: args[0], right: args[1] };
+    // ============ Logical ============
+    case "and":
+      return { kind: "and", args };
+    case "or":
+      return { kind: "or", args };
+    case "not":
+      return { kind: "not", arg: args[0] };
+    // ============ Type Checking ============
+    case "isNull":
+      return { kind: "isNull", arg: args[0] };
+    case "isNotNull":
+      return { kind: "not", arg: { kind: "isNull", arg: args[0] } };
+    case "typeof":
+      return { kind: "typeof", arg: args[0] };
+    case "coalesce":
+      return { kind: "coalesce", args };
+    // ============ String ============
+    case "concat":
+      return { kind: "concat", args };
+    case "trim":
+      return { kind: "trim", str: args[0] };
+    case "lower":
+    case "toLowerCase":
+      return { kind: "toLowerCase", str: args[0] };
+    case "upper":
+    case "toUpperCase":
+      return { kind: "toUpperCase", str: args[0] };
+    case "strlen":
+    case "strLen":
+      return { kind: "strLen", str: args[0] };
+    case "substr":
+    case "substring":
+      return args[2] ? { kind: "substring", str: args[0], start: args[1], end: args[2] } : { kind: "substring", str: args[0], start: args[1] };
+    case "toString":
+      return { kind: "toString", arg: args[0] };
+    // ============ Collection ============
+    case "len":
+    case "length":
+      return { kind: "len", arg: args[0] };
+    case "at":
+      return { kind: "at", array: args[0], index: args[1] };
+    case "first":
+      return { kind: "first", array: args[0] };
+    case "last":
+      return { kind: "last", array: args[0] };
+    case "slice":
+      return args[2] ? { kind: "slice", array: args[0], start: args[1], end: args[2] } : { kind: "slice", array: args[0], start: args[1] };
+    case "includes":
+      return { kind: "includes", array: args[0], item: args[1] };
+    case "filter":
+      return { kind: "filter", array: args[0], predicate: args[1] };
+    case "map":
+      return { kind: "map", array: args[0], mapper: args[1] };
+    case "find":
+      return { kind: "find", array: args[0], predicate: args[1] };
+    case "every":
+      return { kind: "every", array: args[0], predicate: args[1] };
+    case "some":
+      return { kind: "some", array: args[0], predicate: args[1] };
+    case "append":
+      return { kind: "append", array: args[0], items: args.slice(1) };
+    // ============ Object ============
+    case "keys":
+      return { kind: "keys", obj: args[0] };
+    case "values":
+      return { kind: "values", obj: args[0] };
+    case "entries":
+      return { kind: "entries", obj: args[0] };
+    case "merge":
+      return { kind: "merge", objects: args };
+    // ============ Conditional ============
+    case "if":
+    case "cond":
+      return { kind: "if", cond: args[0], then: args[1], else: args[2] };
+    // ============ Unknown Function ============
+    default:
+      return {
+        kind: "object",
+        fields: {
+          __call: { kind: "lit", value: name },
+          __args: { kind: "lit", value: args }
+        }
+      };
+  }
+}
+
+// src/generator/ir.ts
+import { hashSchemaSync, semanticPathToPatchPath, sha256Sync } from "@manifesto-ai/core";
+function createContext2(domainName) {
+  return {
+    domainName,
+    stateFields: /* @__PURE__ */ new Set(),
+    computedFields: /* @__PURE__ */ new Set(),
+    actionParams: /* @__PURE__ */ new Map(),
+    onceIntentCounters: /* @__PURE__ */ new Map(),
+    currentAction: null,
+    diagnostics: [],
+    typeDefs: /* @__PURE__ */ new Map()
+  };
+}
+function generate(program) {
+  const ctx = createContext2(program.domain.name);
+  collectFieldNames(program.domain, ctx);
+  const types = generateTypes(program.domain, ctx);
+  const state = generateState(program.domain, ctx);
+  const computed = generateComputed(program.domain, ctx);
+  const actions = generateActions(program.domain, ctx);
+  if (ctx.diagnostics.some((d) => d.severity === "error")) {
+    return {
+      schema: null,
+      diagnostics: ctx.diagnostics
+    };
+  }
+  const schemaWithoutHash = {
+    id: `mel:${program.domain.name.toLowerCase()}`,
+    version: "1.0.0",
+    types,
+    state,
+    computed,
+    actions,
+    meta: {
+      name: program.domain.name
+    }
+  };
+  const hash = computeHash(schemaWithoutHash);
+  const schema = {
+    ...schemaWithoutHash,
+    hash
+  };
+  return {
+    schema,
+    diagnostics: ctx.diagnostics
+  };
+}
+function collectFieldNames(domain, ctx) {
+  for (const typeDecl of domain.types) {
+    ctx.typeDefs.set(typeDecl.name, typeDecl);
+  }
+  for (const member of domain.members) {
+    if (member.kind === "state") {
+      for (const field of member.fields) {
+        ctx.stateFields.add(field.name);
+      }
+    } else if (member.kind === "computed") {
+      ctx.computedFields.add(member.name);
+    }
+  }
+}
+function generateTypes(domain, _ctx) {
+  const types = {};
+  for (const typeDecl of domain.types) {
+    types[typeDecl.name] = {
+      name: typeDecl.name,
+      definition: typeExprToDefinition(typeDecl.typeExpr)
+    };
+  }
+  return types;
+}
+function typeExprToDefinition(typeExpr) {
+  switch (typeExpr.kind) {
+    case "simpleType":
+      if (["string", "number", "boolean", "null"].includes(typeExpr.name)) {
+        return { kind: "primitive", type: typeExpr.name };
+      }
+      return { kind: "ref", name: typeExpr.name };
+    case "arrayType":
+      return {
+        kind: "array",
+        element: typeExprToDefinition(typeExpr.elementType)
+      };
+    case "recordType":
+      return {
+        kind: "record",
+        key: typeExprToDefinition(typeExpr.keyType),
+        value: typeExprToDefinition(typeExpr.valueType)
+      };
+    case "objectType":
+      const fields = {};
+      for (const field of typeExpr.fields) {
+        fields[field.name] = {
+          type: typeExprToDefinition(field.typeExpr),
+          optional: field.optional
+        };
+      }
+      return { kind: "object", fields };
+    case "unionType":
+      return {
+        kind: "union",
+        types: typeExpr.types.map(typeExprToDefinition)
+      };
+    case "literalType":
+      return { kind: "literal", value: typeExpr.value };
+    default:
+      const _exhaustive = typeExpr;
+      throw new Error(`Unknown type expression kind: ${typeExpr.kind}`);
+  }
+}
+function generateState(domain, ctx) {
+  const fields = {};
+  for (const member of domain.members) {
+    if (member.kind === "state") {
+      for (const field of member.fields) {
+        fields[field.name] = generateFieldSpec(field, ctx);
+      }
+    }
+  }
+  return { fields };
+}
+function generateFieldSpec(field, ctx) {
+  const spec = typeExprToFieldSpec(field.typeExpr, ctx);
+  const defaultValue = field.initializer ? evaluateInitializer(field.initializer, ctx) : void 0;
+  return {
+    ...spec,
+    required: true,
+    default: defaultValue
+  };
+}
+function typeExprToFieldSpec(typeExpr, ctx) {
+  switch (typeExpr.kind) {
+    case "simpleType":
+      switch (typeExpr.name) {
+        case "string":
+          return { type: "string", required: true };
+        case "number":
+          return { type: "number", required: true };
+        case "boolean":
+          return { type: "boolean", required: true };
+        case "null":
+          return { type: "null", required: true };
+        default: {
+          const typeDef = ctx.typeDefs.get(typeExpr.name);
+          if (typeDef) {
+            return typeExprToFieldSpec(typeDef.typeExpr, ctx);
+          }
+          return { type: "object", required: true };
+        }
+      }
+    case "unionType": {
+      const literals = [];
+      let isLiteralUnion = true;
+      let hasNull = false;
+      for (const t of typeExpr.types) {
+        if (t.kind === "literalType") {
+          if (t.value === null) {
+            hasNull = true;
+          }
+          literals.push(t.value);
+          continue;
+        }
+        if (t.kind === "simpleType" && t.name === "null") {
+          hasNull = true;
+          literals.push(null);
+          continue;
+        }
+        isLiteralUnion = false;
+      }
+      if (isLiteralUnion && literals.length > 0) {
+        return { type: { enum: literals }, required: !hasNull };
+      }
+      if (hasNull) {
+        for (const t of typeExpr.types) {
+          if (t.kind !== "simpleType" || t.name !== "null") {
+            const innerSpec = typeExprToFieldSpec(t, ctx);
+            return { ...innerSpec, required: false };
+          }
+        }
+      }
+      for (const t of typeExpr.types) {
+        if (t.kind !== "simpleType" || t.name !== "null") {
+          return typeExprToFieldSpec(t, ctx);
+        }
+      }
+      return { type: "null", required: true };
+    }
+    case "arrayType": {
+      const itemSpec = typeExprToFieldSpec(typeExpr.elementType, ctx);
+      return {
+        type: "array",
+        required: true,
+        items: itemSpec
+      };
+    }
+    case "recordType":
+      return { type: "object", required: true };
+    case "literalType":
+      if (typeof typeExpr.value === "string") return { type: "string", required: true };
+      if (typeof typeExpr.value === "number") return { type: "number", required: true };
+      if (typeof typeExpr.value === "boolean") return { type: "boolean", required: true };
+      return { type: "null", required: true };
+    case "objectType": {
+      const objectFields = {};
+      for (const field of typeExpr.fields) {
+        const fieldSpec = typeExprToFieldSpec(field.typeExpr, ctx);
+        objectFields[field.name] = {
+          ...fieldSpec,
+          required: !field.optional
+        };
+      }
+      return {
+        type: "object",
+        required: true,
+        fields: objectFields
+      };
+    }
+  }
+}
+function evaluateInitializer(expr, ctx) {
+  switch (expr.kind) {
+    case "literal":
+      return expr.value;
+    case "arrayLiteral":
+      return expr.elements.map((e) => evaluateInitializer(e, ctx));
+    case "objectLiteral": {
+      const obj = {};
+      for (const prop of expr.properties) {
+        obj[prop.key] = evaluateInitializer(prop.value, ctx);
+      }
+      return obj;
+    }
+    default:
+      return void 0;
+  }
+}
+function generateComputed(domain, ctx) {
+  const fields = {};
+  for (const member of domain.members) {
+    if (member.kind === "computed") {
+      const expr = generateExpr(member.expression, ctx);
+      const deps = extractDeps(expr);
+      fields[member.name] = {
+        deps,
+        expr
+      };
+    }
+  }
+  return { fields };
+}
+function extractDeps(expr) {
+  const deps = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (node.kind === "get") {
+      deps.add(node.path);
+    } else {
+      for (const value of Object.values(node)) {
+        if (typeof value === "object" && value !== null) {
+          if (Array.isArray(value)) {
+            for (const item of value) {
+              if (typeof item === "object" && item !== null && "kind" in item) {
+                visit(item);
+              }
+            }
+          } else if ("kind" in value) {
+            visit(value);
+          }
+        }
+      }
+    }
+  }
+  visit(expr);
+  return Array.from(deps);
+}
+function generateActions(domain, ctx) {
+  const actions = {};
+  for (const member of domain.members) {
+    if (member.kind === "action") {
+      ctx.currentAction = member.name;
+      ctx.onceIntentCounters.set(member.name, 0);
+      const params = /* @__PURE__ */ new Set();
+      for (const param of member.params) {
+        params.add(param.name);
+      }
+      ctx.actionParams.set(member.name, params);
+      const flow = generateFlow(member.body, ctx);
+      let input;
+      if (member.params.length > 0) {
+        const inputFields = {};
+        for (const param of member.params) {
+          const fieldSpec = typeExprToFieldSpec(param.typeExpr, ctx);
+          const inputField = {
+            type: fieldSpec.type,
+            required: fieldSpec.required ?? true
+          };
+          if (fieldSpec.type === "object" && fieldSpec.fields) {
+            inputField.fields = fieldSpec.fields;
+          }
+          if (fieldSpec.type === "array" && fieldSpec.items) {
+            inputField.items = fieldSpec.items;
+          }
+          inputFields[param.name] = inputField;
+        }
+        input = {
+          type: "object",
+          required: true,
+          fields: inputFields
+        };
+      }
+      let available;
+      if (member.available) {
+        available = generateExpr(member.available, ctx);
+      }
+      actions[member.name] = {
+        flow,
+        input,
+        available
+      };
+      ctx.currentAction = null;
+    }
+  }
+  return actions;
+}
+function generateFlow(stmts, ctx) {
+  if (stmts.length === 0) {
+    return { kind: "seq", steps: [] };
+  }
+  if (stmts.length === 1) {
+    return generateStmt(stmts[0], ctx);
+  }
+  return {
+    kind: "seq",
+    steps: stmts.map((s) => generateStmt(s, ctx))
+  };
+}
+function generateStmt(stmt, ctx) {
+  switch (stmt.kind) {
+    case "when":
+      return generateWhen(stmt, ctx);
+    case "once":
+      return generateOnce(stmt, ctx);
+    case "onceIntent":
+      return generateOnceIntent(stmt, ctx);
+    case "patch":
+      return generatePatch(stmt, ctx);
+    case "effect":
+      return generateEffect(stmt, ctx);
+    case "fail":
+      return generateFail(stmt, ctx);
+    case "stop":
+      return generateStop(stmt, ctx);
+  }
+}
+function generateWhen(stmt, ctx) {
+  const cond = generateExpr(stmt.condition, ctx);
+  const thenFlow = generateFlow(stmt.body, ctx);
+  return {
+    kind: "if",
+    cond,
+    then: thenFlow
+  };
+}
+function generateOnce(stmt, ctx) {
+  const markerPath = generatePath(stmt.marker, ctx);
+  const intentIdExpr = { kind: "get", path: "meta.intentId" };
+  let cond = {
+    kind: "neq",
+    left: { kind: "get", path: markerPath },
+    right: intentIdExpr
+  };
+  if (stmt.condition) {
+    const extraCond = generateExpr(stmt.condition, ctx);
+    cond = {
+      kind: "and",
+      args: [cond, extraCond]
+    };
+  }
+  const markerPatch = {
+    kind: "patch",
+    op: "set",
+    path: toPatchPath(markerPath),
+    value: intentIdExpr
+  };
+  const bodySteps = stmt.body.map((s) => generateStmt(s, ctx));
+  return {
+    kind: "if",
+    cond,
+    then: {
+      kind: "seq",
+      steps: [markerPatch, ...bodySteps]
+    }
+  };
+}
+function generateOnceIntent(stmt, ctx) {
+  const actionName = ctx.currentAction ?? "unknown";
+  const nextIndex = ctx.onceIntentCounters.get(actionName) ?? 0;
+  ctx.onceIntentCounters.set(actionName, nextIndex + 1);
+  const guardId = sha256Sync(`${actionName}:${nextIndex}:intent`);
+  const guardPath = `$mel.guards.intent.${guardId}`;
+  const intentIdExpr = { kind: "get", path: "meta.intentId" };
+  let cond = {
+    kind: "neq",
+    left: { kind: "get", path: guardPath },
+    right: intentIdExpr
+  };
+  if (stmt.condition) {
+    const extraCond = generateExpr(stmt.condition, ctx);
+    cond = {
+      kind: "and",
+      args: [cond, extraCond]
+    };
+  }
+  const markerPatch = {
+    kind: "patch",
+    op: "merge",
+    path: toPatchPath("$mel.guards.intent"),
+    value: {
+      kind: "object",
+      fields: { [guardId]: intentIdExpr }
+    }
+  };
+  const bodySteps = stmt.body.map((s) => generateStmt(s, ctx));
+  return {
+    kind: "if",
+    cond,
+    then: {
+      kind: "seq",
+      steps: [markerPatch, ...bodySteps]
+    }
+  };
+}
+function generatePatch(stmt, ctx) {
+  const path = generatePath(stmt.path, ctx);
+  const result = {
+    kind: "patch",
+    op: stmt.op,
+    path: toPatchPath(path)
+  };
+  if (stmt.value) {
+    result.value = generateExpr(stmt.value, ctx);
+  }
+  return result;
+}
+function generateEffect(stmt, ctx) {
+  const params = {};
+  for (const arg of stmt.args) {
+    if (arg.isPath) {
+      params[arg.name] = { kind: "lit", value: generatePath(arg.value, ctx) };
+    } else {
+      params[arg.name] = generateExpr(arg.value, ctx);
+    }
+  }
+  return {
+    kind: "effect",
+    type: stmt.effectType,
+    params
+  };
+}
+function generateFail(stmt, ctx) {
+  const result = {
+    kind: "fail",
+    code: stmt.code
+  };
+  if (stmt.message) {
+    result.message = generateExpr(stmt.message, ctx);
+  }
+  return result;
+}
+function generateStop(stmt, ctx) {
+  return {
+    kind: "halt",
+    reason: stmt.reason
+  };
+}
+function escapePathSegment(segment) {
+  return segment.replaceAll("\\", "\\\\").replaceAll(".", "\\.");
+}
+function joinPathPreserveEmptySegments(...segments) {
+  return segments.map(escapePathSegment).join(".");
+}
+function generatePath(path, ctx) {
+  const segments = [];
+  for (const segment of path.segments) {
+    if (segment.kind === "propertySegment") {
+      segments.push(segment.name);
+    } else {
+      const indexExpr = generateExpr(segment.index, ctx);
+      if (indexExpr.kind === "lit") {
+        segments.push(String(indexExpr.value));
+      } else {
+        segments.push("*");
+      }
+    }
+  }
+  const first = segments[0];
+  if (ctx.stateFields.has(first)) {
+    return joinPathPreserveEmptySegments(...segments);
+  }
+  if (ctx.computedFields.has(first)) {
+    return joinPathPreserveEmptySegments(...segments);
+  }
+  if (ctx.currentAction && ctx.actionParams.get(ctx.currentAction)?.has(first)) {
+    return `input.${joinPathPreserveEmptySegments(...segments)}`;
+  }
+  return joinPathPreserveEmptySegments(...segments);
+}
+function toPatchPath(path) {
+  return semanticPathToPatchPath(path);
+}
+function generateExpr(expr, ctx) {
+  switch (expr.kind) {
+    case "literal":
+      return { kind: "lit", value: expr.value };
+    case "identifier":
+      return generateIdentifier(expr.name, ctx);
+    case "systemIdent":
+      return generateSystemIdent(expr.path, ctx);
+    case "iterationVar":
+      return { kind: "get", path: `$${expr.name}` };
+    case "propertyAccess":
+      return generatePropertyAccess(expr, ctx);
+    case "indexAccess":
+      return {
+        kind: "at",
+        array: generateExpr(expr.object, ctx),
+        index: generateExpr(expr.index, ctx)
+      };
+    case "functionCall":
+      return normalizeFunctionCall(
+        expr.name,
+        expr.args.map((a) => generateExpr(a, ctx))
+      );
+    case "binary":
+      return normalizeExpr(
+        expr.operator,
+        generateExpr(expr.left, ctx),
+        generateExpr(expr.right, ctx)
+      );
+    case "unary":
+      if (expr.operator === "!") {
+        return { kind: "not", arg: generateExpr(expr.operand, ctx) };
+      } else {
+        return { kind: "neg", arg: generateExpr(expr.operand, ctx) };
+      }
+    case "ternary":
+      return {
+        kind: "if",
+        cond: generateExpr(expr.condition, ctx),
+        then: generateExpr(expr.consequent, ctx),
+        else: generateExpr(expr.alternate, ctx)
+      };
+    case "objectLiteral": {
+      const fields = {};
+      for (const prop of expr.properties) {
+        fields[prop.key] = generateExpr(prop.value, ctx);
+      }
+      return { kind: "object", fields };
+    }
+    case "arrayLiteral":
+      if (expr.elements.length === 0) {
+        return { kind: "lit", value: [] };
+      }
+      const allLiterals = expr.elements.every((e) => e.kind === "literal");
+      if (allLiterals) {
+        return { kind: "lit", value: expr.elements.map((e) => e.value) };
+      }
+      return {
+        kind: "append",
+        array: { kind: "lit", value: [] },
+        items: expr.elements.map((e) => generateExpr(e, ctx))
+      };
+  }
+}
+function generateIdentifier(name, ctx) {
+  if (ctx.stateFields.has(name)) {
+    return { kind: "get", path: name };
+  }
+  if (ctx.computedFields.has(name)) {
+    return { kind: "get", path: name };
+  }
+  if (ctx.currentAction && ctx.actionParams.get(ctx.currentAction)?.has(name)) {
+    return { kind: "get", path: `input.${name}` };
+  }
+  ctx.diagnostics.push({
+    severity: "error",
+    code: "E_UNKNOWN_IDENT",
+    message: `Unknown identifier '${name}'`,
+    location: { start: { line: 0, column: 0, offset: 0 }, end: { line: 0, column: 0, offset: 0 } }
+  });
+  return { kind: "get", path: name };
+}
+function generateSystemIdent(path, ctx) {
+  const [namespace, ...rest] = path;
+  switch (namespace) {
+    case "system":
+      return { kind: "get", path: `$system.${rest.join(".")}` };
+    case "meta":
+      return { kind: "get", path: `meta.${rest.join(".")}` };
+    case "input":
+      return { kind: "get", path: `input.${rest.join(".")}` };
+    default:
+      ctx.diagnostics.push({
+        severity: "error",
+        code: "E_INVALID_SYSTEM",
+        message: `Invalid system identifier namespace '$${namespace}'`,
+        location: { start: { line: 0, column: 0, offset: 0 }, end: { line: 0, column: 0, offset: 0 } }
+      });
+      return { kind: "lit", value: null };
+  }
+}
+function generatePropertyAccess(expr, ctx) {
+  const objectExpr = generateExpr(expr.object, ctx);
+  if (objectExpr.kind === "get") {
+    return { kind: "get", path: `${objectExpr.path}.${expr.property}` };
+  }
+  return {
+    kind: "field",
+    object: objectExpr,
+    property: expr.property
+  };
+}
+function computeHash(schema) {
+  return hashSchemaSync(schema);
+}
+
+// src/lowering/errors.ts
+var LoweringError = class extends Error {
+  code;
+  path;
+  details;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "LoweringError";
+    this.code = code;
+    this.path = options?.path;
+    this.details = options?.details;
+  }
+};
+function invalidKindForContext(kind, context, path) {
+  return new LoweringError(
+    "INVALID_KIND_FOR_CONTEXT",
+    `Node kind '${kind}' is not allowed in ${context} context`,
+    { path, details: { kind, context } }
+  );
+}
+function unknownCallFn(fn, path) {
+  return new LoweringError(
+    "UNKNOWN_CALL_FN",
+    `Unknown function '${fn}' in call expression`,
+    { path, details: { fn } }
+  );
+}
+function invalidSysPath(sysPath, path) {
+  return new LoweringError(
+    "INVALID_SYS_PATH",
+    `System path '${sysPath.join(".")}' is not allowed in Translator path`,
+    { path, details: { sysPath } }
+  );
+}
+function unsupportedBase(baseKind, path) {
+  return new LoweringError(
+    "UNSUPPORTED_BASE",
+    `Unsupported base expression kind '${baseKind}'. Only var(item) is supported.`,
+    { path, details: { baseKind } }
+  );
+}
+function invalidShape(description, path) {
+  return new LoweringError(
+    "INVALID_SHAPE",
+    `Invalid node shape: ${description}`,
+    { path, details: { description } }
+  );
+}
+function unknownNodeKind(kind, path) {
+  return new LoweringError(
+    "UNKNOWN_NODE_KIND",
+    `Unknown expression node kind '${kind}'`,
+    { path, details: { kind } }
+  );
+}
+
+// src/lowering/lower-expr.ts
+function lowerExprNode(input, ctx) {
+  switch (input.kind) {
+    case "lit":
+      return lowerLit(input);
+    case "var":
+      return lowerVar(input, ctx);
+    case "sys":
+      return lowerSys(input, ctx);
+    case "get":
+      return lowerGet(input, ctx);
+    case "call":
+      return lowerCall(input, ctx);
+    case "obj":
+      return lowerObj(input, ctx);
+    case "arr":
+      return lowerArr(input, ctx);
+    default:
+      throw unknownNodeKind(input.kind);
+  }
+}
+function lowerLit(input) {
+  return { kind: "lit", value: input.value };
+}
+function lowerVar(input, ctx) {
+  if (!ctx.allowItem) {
+    throw invalidKindForContext("var", ctx.mode);
+  }
+  return { kind: "get", path: "$item" };
+}
+function lowerSys(input, ctx) {
+  if (input.path.length === 0) {
+    throw invalidSysPath(input.path);
+  }
+  const prefix = input.path[0];
+  const allowedPrefixes = ctx.allowSysPaths?.prefixes ?? ["meta", "input"];
+  if (!allowedPrefixes.includes(prefix)) {
+    throw invalidSysPath(input.path);
+  }
+  const path = input.path.join(".");
+  return { kind: "get", path };
+}
+function lowerGet(input, ctx) {
+  const pathStr = input.path.map((seg) => seg.name).join(".");
+  if (input.base === void 0) {
+    return { kind: "get", path: pathStr };
+  }
+  if (input.base.kind === "var" && input.base.name === "item") {
+    if (!ctx.allowItem) {
+      throw invalidKindForContext("var", ctx.mode);
+    }
+    return { kind: "get", path: `$item.${pathStr}` };
+  }
+  throw unsupportedBase(input.base.kind);
+}
+function lowerCall(input, ctx) {
+  const { fn, args } = input;
+  if (isBinaryOp2(fn)) {
+    if (args.length !== 2) {
+      throw unknownCallFn(fn);
+    }
+    const [left, right] = args;
+    return {
+      kind: fn,
+      left: lowerExprNode(left, ctx),
+      right: lowerExprNode(right, ctx)
+    };
+  }
+  if (isUnaryArgOp(fn)) {
+    if (args.length !== 1) {
+      throw unknownCallFn(fn);
+    }
+    return {
+      kind: fn,
+      arg: lowerExprNode(args[0], ctx)
+    };
+  }
+  if (fn === "trim") {
+    if (args.length !== 1) {
+      throw unknownCallFn(fn);
+    }
+    return {
+      kind: "trim",
+      str: lowerExprNode(args[0], ctx)
+    };
+  }
+  if (isArgsOp(fn)) {
+    return {
+      kind: fn,
+      args: args.map((a) => lowerExprNode(a, ctx))
+    };
+  }
+  if (fn === "if") {
+    if (args.length !== 3) {
+      throw unknownCallFn(fn);
+    }
+    return {
+      kind: "if",
+      cond: lowerExprNode(args[0], ctx),
+      then: lowerExprNode(args[1], ctx),
+      else: lowerExprNode(args[2], ctx)
+    };
+  }
+  if (fn === "field") {
+    if (args.length !== 2) {
+      throw unknownCallFn(fn);
+    }
+    const object = lowerExprNode(args[0], ctx);
+    const property = args[1];
+    if (property.kind !== "lit" || typeof property.value !== "string") {
+      throw unknownCallFn(fn);
+    }
+    return {
+      kind: "field",
+      object,
+      property: property.value
+    };
+  }
+  if (isArrayArgOp(fn)) {
+    if (args.length !== 1) {
+      throw unknownCallFn(fn);
+    }
+    return {
+      kind: fn,
+      array: lowerExprNode(args[0], ctx)
+    };
+  }
+  if (isObjArgOp(fn)) {
+    if (args.length !== 1) {
+      throw unknownCallFn(fn);
+    }
+    return {
+      kind: fn,
+      obj: lowerExprNode(args[0], ctx)
+    };
+  }
+  if (fn === "at") {
+    if (args.length !== 2) {
+      throw unknownCallFn(fn);
+    }
+    return {
+      kind: "at",
+      array: lowerExprNode(args[0], ctx),
+      index: lowerExprNode(args[1], ctx)
+    };
+  }
+  if (fn === "includes") {
+    if (args.length !== 2) {
+      throw unknownCallFn(fn);
+    }
+    return {
+      kind: "includes",
+      array: lowerExprNode(args[0], ctx),
+      item: lowerExprNode(args[1], ctx)
+    };
+  }
+  if (isPredicateOp(fn)) {
+    if (args.length !== 2) {
+      throw unknownCallFn(fn);
+    }
+    const predicateCtx = { ...ctx, allowItem: true };
+    if (fn === "map") {
+      return {
+        kind: "map",
+        array: lowerExprNode(args[0], ctx),
+        mapper: lowerExprNode(args[1], predicateCtx)
+      };
+    }
+    return {
+      kind: fn,
+      array: lowerExprNode(args[0], ctx),
+      predicate: lowerExprNode(args[1], predicateCtx)
+    };
+  }
+  if (fn === "slice") {
+    if (args.length < 2 || args.length > 3) {
+      throw unknownCallFn(fn);
+    }
+    const result = {
+      kind: "slice",
+      array: lowerExprNode(args[0], ctx),
+      start: lowerExprNode(args[1], ctx)
+    };
+    if (args.length === 3) {
+      result.end = lowerExprNode(args[2], ctx);
+    }
+    return result;
+  }
+  if (fn === "substring") {
+    if (args.length < 2 || args.length > 3) {
+      throw unknownCallFn(fn);
+    }
+    const result = {
+      kind: "substring",
+      str: lowerExprNode(args[0], ctx),
+      start: lowerExprNode(args[1], ctx)
+    };
+    if (args.length === 3) {
+      result.end = lowerExprNode(args[2], ctx);
+    }
+    return result;
+  }
+  if (fn === "append") {
+    if (args.length < 1) {
+      throw unknownCallFn(fn);
+    }
+    return {
+      kind: "append",
+      array: lowerExprNode(args[0], ctx),
+      items: args.slice(1).map((a) => lowerExprNode(a, ctx))
+    };
+  }
+  if (fn === "merge") {
+    return {
+      kind: "merge",
+      objects: args.map((a) => lowerExprNode(a, ctx))
+    };
+  }
+  throw unknownCallFn(fn);
+}
+function lowerObj(input, ctx) {
+  const fields = {};
+  for (const field of input.fields) {
+    fields[field.key] = lowerExprNode(field.value, ctx);
+  }
+  return { kind: "object", fields };
+}
+function lowerArr(input, ctx) {
+  const allLiterals = input.elements.every((e) => e.kind === "lit");
+  if (allLiterals) {
+    const values = input.elements.map(
+      (e) => e.value
+    );
+    return { kind: "lit", value: values };
+  }
+  const loweredElements = input.elements.map((e) => lowerExprNode(e, ctx));
+  if (loweredElements.length === 0) {
+    return { kind: "lit", value: [] };
+  }
+  return {
+    kind: "append",
+    array: { kind: "lit", value: [] },
+    items: loweredElements
+  };
+}
+function isBinaryOp2(fn) {
+  return [
+    "eq",
+    "neq",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "add",
+    "sub",
+    "mul",
+    "div",
+    "mod"
+  ].includes(fn);
+}
+function isUnaryArgOp(fn) {
+  return ["not", "len", "typeof", "isNull"].includes(fn);
+}
+function isArgsOp(fn) {
+  return ["and", "or", "concat", "coalesce"].includes(fn);
+}
+function isArrayArgOp(fn) {
+  return ["first", "last"].includes(fn);
+}
+function isObjArgOp(fn) {
+  return ["keys", "values", "entries"].includes(fn);
+}
+function isPredicateOp(fn) {
+  return ["filter", "find", "every", "some", "map"].includes(fn);
+}
+
+// src/lowering/lower-runtime-patch.ts
+function lowerRuntimePatches(patches, ctx) {
+  return patches.map((patch) => lowerRuntimePatch(patch, ctx));
+}
+function lowerRuntimePatch(patch, ctx) {
+  const condition = patch.condition ? lowerExprNode(patch.condition, ctx) : void 0;
+  const value = patch.value ? lowerExprNode(patch.value, ctx) : void 0;
+  return {
+    condition,
+    op: patch.op,
+    path: lowerRuntimePath(patch.path, ctx),
+    value
+  };
+}
+function lowerRuntimePath(path, ctx) {
+  return path.map((segment) => {
+    if (segment.kind === "prop") {
+      return segment;
+    }
+    return { kind: "expr", expr: lowerExprNode(segment.expr, ctx) };
+  });
+}
+
+// src/api/compile-mel-patch-collector.ts
+import { sha256Sync as sha256Sync2 } from "@manifesto-ai/core";
+
+// src/api/compile-mel-patch-expr.ts
+function isSyntheticPatchCondition(condition) {
+  return condition.kind === "literal" && condition.literalType === "boolean" && condition.value === true;
+}
+function toMelExpr(input) {
+  switch (input.kind) {
+    case "literal":
+      return { kind: "lit", value: toMelPrimitive(input.value, input.literalType) };
+    case "identifier":
+      return {
+        kind: "get",
+        path: [{ kind: "prop", name: input.name }]
+      };
+    case "systemIdent":
+      return { kind: "sys", path: input.path };
+    case "iterationVar":
+      return { kind: "var", name: input.name };
+    case "propertyAccess": {
+      const path = collectStaticMelExpr(input);
+      if (path) {
+        return path;
+      }
+      return {
+        kind: "call",
+        fn: "field",
+        args: [toMelExpr(input.object), { kind: "lit", value: input.property }]
+      };
+    }
+    case "indexAccess": {
+      return {
+        kind: "call",
+        fn: "at",
+        args: [toMelExpr(input.object), toMelExpr(input.index)]
+      };
+    }
+    case "functionCall":
+      return {
+        kind: "call",
+        fn: input.name,
+        args: input.args.map(toMelExpr)
+      };
+    case "unary":
+      if (input.operator === "!") {
+        return {
+          kind: "call",
+          fn: "not",
+          args: [toMelExpr(input.operand)]
+        };
+      }
+      return {
+        kind: "call",
+        fn: "sub",
+        args: [{ kind: "lit", value: 0 }, toMelExpr(input.operand)]
+      };
+    case "binary":
+      return {
+        kind: "call",
+        fn: toMelBinaryOp(input.operator),
+        args: [toMelExpr(input.left), toMelExpr(input.right)]
+      };
+    case "ternary":
+      return {
+        kind: "call",
+        fn: "if",
+        args: [
+          toMelExpr(input.condition),
+          toMelExpr(input.consequent),
+          toMelExpr(input.alternate)
+        ]
+      };
+    case "objectLiteral":
+      return {
+        kind: "obj",
+        fields: input.properties.map((property) => ({
+          key: property.key,
+          value: toMelExpr(property.value)
+        }))
+      };
+    case "arrayLiteral":
+      return {
+        kind: "arr",
+        elements: input.elements.map(toMelExpr)
+      };
+    default:
+      throw new Error(`Unsupported expression kind '${input.kind}'`);
+  }
+}
+function toMelPrimitive(value, literalType) {
+  if (literalType === "null") {
+    return null;
+  }
+  if (literalType === "number") {
+    if (typeof value === "number") {
+      return value;
+    }
+    if (typeof value === "bigint") {
+      return Number(value);
+    }
+    if (typeof value === "string" && value.length > 0) {
+      const parsed = Number(value);
+      if (!Number.isNaN(parsed)) {
+        return parsed;
+      }
+    }
+    throw new Error("Invalid number literal");
+  }
+  if (literalType === "string") {
+    if (typeof value === "string") {
+      return value;
+    }
+    throw new Error("Invalid string literal");
+  }
+  if (literalType === "boolean") {
+    if (typeof value === "boolean") {
+      return value;
+    }
+    throw new Error("Invalid boolean literal");
+  }
+  throw new Error("Unsupported literal type");
+}
+function collectStaticMelExpr(expr) {
+  if (expr.kind === "identifier") {
+    return { kind: "get", path: [{ kind: "prop", name: expr.name }] };
+  }
+  if (expr.kind === "iterationVar") {
+    if (expr.name !== "item") {
+      return null;
+    }
+    return { kind: "var", name: "item" };
+  }
+  if (expr.kind === "propertyAccess") {
+    const basePath = collectStaticMelExpr(expr.object);
+    if (!basePath) {
+      return null;
+    }
+    return {
+      kind: "call",
+      fn: "field",
+      args: [basePath, { kind: "lit", value: expr.property }]
+    };
+  }
+  return null;
+}
+function toMelBinaryOp(op) {
+  switch (op) {
+    case "+":
+      return "add";
+    case "-":
+      return "sub";
+    case "*":
+      return "mul";
+    case "/":
+      return "div";
+    case "%":
+      return "mod";
+    case "==":
+      return "eq";
+    case "!=":
+      return "neq";
+    case "<":
+      return "lt";
+    case "<=":
+      return "lte";
+    case ">":
+      return "gt";
+    case ">=":
+      return "gte";
+    case "&&":
+      return "and";
+    case "||":
+      return "or";
+    case "??":
+      return "coalesce";
+    default:
+      throw new Error(`Unsupported binary operator '${op}'`);
+  }
+}
+
+// src/api/compile-mel-patch-collector.ts
+var PatchStatementCollector = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  conditionComposer = new ConditionComposer();
+  collect(stmts, errors, context, parentCondition) {
+    return this.collectPatchStatements(stmts, errors, context, parentCondition);
+  }
+  collectPatchStatements(stmts, errors, context, parentCondition) {
+    const patchStatements = [];
+    for (const stmt of stmts) {
+      if (stmt.kind === "patch") {
+        patchStatements.push({
+          patch: stmt,
+          condition: parentCondition
+        });
+        continue;
+      }
+      if (stmt.kind === "when") {
+        let condition = parentCondition;
+        try {
+          condition = this.conditionComposer.and(
+            parentCondition,
+            this.deps.toMelExpr(stmt.condition)
+          );
+        } catch (error) {
+          errors.push({
+            severity: "error",
+            code: "E_LOWER",
+            message: error.message,
+            location: this.deps.mapLocation(stmt.condition.location)
+          });
+        }
+        const whenMarkerId = sha256Sync2(
+          `${context.actionName}:${context.whenCounter}:when`
+        );
+        context.whenCounter += 1;
+        const whenMarkerPath = {
+          kind: "path",
+          segments: [
+            {
+              kind: "propertySegment",
+              name: "$mel",
+              location: stmt.location
+            },
+            {
+              kind: "propertySegment",
+              name: "__whenGuards",
+              location: stmt.location
+            },
+            {
+              kind: "propertySegment",
+              name: whenMarkerId,
+              location: stmt.location
+            }
+          ],
+          location: stmt.location
+        };
+        const whenMarkerExpr = pathToMelExpr(whenMarkerPath);
+        const guardedBody = this.collectPatchStatements(
+          stmt.body,
+          errors,
+          context,
+          void 0
+        ).map((statement) => ({
+          patch: statement.patch,
+          condition: this.conditionComposer.and(whenMarkerExpr, statement.condition)
+        }));
+        patchStatements.push(
+          {
+            patch: {
+              kind: "patch",
+              op: "set",
+              path: whenMarkerPath,
+              value: {
+                kind: "literal",
+                literalType: "boolean",
+                value: true,
+                location: stmt.location
+              },
+              location: stmt.location
+            },
+            condition
+          },
+          ...guardedBody,
+          {
+            patch: {
+              kind: "patch",
+              op: "unset",
+              path: whenMarkerPath,
+              location: stmt.location
+            }
+          }
+        );
+        continue;
+      }
+      if (stmt.kind === "once") {
+        let condition = parentCondition;
+        const markerExpr = pathToMelExpr(stmt.marker);
+        const markerPath = stmt.marker;
+        const markerLocation = stmt.location;
+        let onceCondition = {
+          kind: "call",
+          fn: "neq",
+          args: [markerExpr, { kind: "sys", path: ["meta", "intentId"] }]
+        };
+        if (stmt.condition) {
+          try {
+            onceCondition = this.conditionComposer.and(
+              onceCondition,
+              this.deps.toMelExpr(stmt.condition)
+            ) ?? onceCondition;
+          } catch (error) {
+            errors.push({
+              severity: "error",
+              code: "E_LOWER",
+              message: error.message,
+              location: this.deps.mapLocation(stmt.condition.location)
+            });
+          }
+        }
+        condition = this.conditionComposer.and(parentCondition, onceCondition);
+        const onceScopeMarkerId = sha256Sync2(
+          `${context.actionName}:${context.onceCounter}:once`
+        );
+        context.onceCounter += 1;
+        const onceScopeMarkerPath = {
+          kind: "path",
+          segments: [
+            {
+              kind: "propertySegment",
+              name: "$mel",
+              location: markerLocation
+            },
+            {
+              kind: "propertySegment",
+              name: "__onceScopeGuards",
+              location: markerLocation
+            },
+            {
+              kind: "propertySegment",
+              name: onceScopeMarkerId,
+              location: markerLocation
+            }
+          ],
+          location: markerLocation
+        };
+        const onceScopeMarkerExpr = pathToMelExpr(onceScopeMarkerPath);
+        const scopedBodyPatchStatements = this.collectPatchStatements(
+          stmt.body,
+          errors,
+          context,
+          onceScopeMarkerExpr
+        );
+        patchStatements.push(
+          {
+            patch: {
+              kind: "patch",
+              op: "set",
+              path: onceScopeMarkerPath,
+              value: {
+                kind: "literal",
+                literalType: "boolean",
+                value: true,
+                location: markerLocation
+              },
+              location: markerLocation
+            },
+            condition
+          },
+          {
+            patch: {
+              kind: "patch",
+              op: "set",
+              path: markerPath,
+              value: {
+                kind: "systemIdent",
+                path: ["meta", "intentId"],
+                location: markerLocation
+              },
+              location: markerLocation
+            },
+            condition: onceScopeMarkerExpr
+          },
+          ...scopedBodyPatchStatements,
+          {
+            patch: {
+              kind: "patch",
+              op: "unset",
+              path: onceScopeMarkerPath,
+              location: markerLocation
+            },
+            condition
+          }
+        );
+        continue;
+      }
+      if (stmt.kind === "onceIntent") {
+        const markerScopeId = sha256Sync2(
+          `${context.actionName}:${context.onceCounter}:onceIntent`
+        );
+        context.onceCounter += 1;
+        const markerScopePath = {
+          kind: "path",
+          segments: [
+            {
+              kind: "propertySegment",
+              name: "$mel",
+              location: stmt.location
+            },
+            {
+              kind: "propertySegment",
+              name: "__onceScopeGuards",
+              location: stmt.location
+            },
+            {
+              kind: "propertySegment",
+              name: markerScopeId,
+              location: stmt.location
+            }
+          ],
+          location: stmt.location
+        };
+        const markerScopeExpr = pathToMelExpr(markerScopePath);
+        const onceIntentGuardId = sha256Sync2(
+          `${context.actionName}:${context.onceIntentCounter}:intent`
+        );
+        context.onceIntentCounter += 1;
+        const markerLocation = stmt.location;
+        const onceIntentGuardPath = {
+          kind: "path",
+          segments: [
+            {
+              kind: "propertySegment",
+              name: "$mel",
+              location: markerLocation
+            },
+            {
+              kind: "propertySegment",
+              name: "guards",
+              location: markerLocation
+            },
+            {
+              kind: "propertySegment",
+              name: "intent",
+              location: markerLocation
+            },
+            {
+              kind: "propertySegment",
+              name: onceIntentGuardId,
+              location: markerLocation
+            }
+          ],
+          location: markerLocation
+        };
+        let onceIntentCondition = {
+          kind: "call",
+          fn: "neq",
+          args: [
+            pathToMelExpr(onceIntentGuardPath),
+            { kind: "sys", path: ["meta", "intentId"] }
+          ]
+        };
+        if (stmt.condition) {
+          try {
+            onceIntentCondition = this.conditionComposer.and(
+              onceIntentCondition,
+              this.deps.toMelExpr(stmt.condition)
+            ) ?? onceIntentCondition;
+          } catch (error) {
+            errors.push({
+              severity: "error",
+              code: "E_LOWER",
+              message: error.message,
+              location: this.deps.mapLocation(stmt.condition.location)
+            });
+          }
+        }
+        const condition = this.conditionComposer.and(parentCondition, onceIntentCondition);
+        const onceIntentGuardMapPath = {
+          kind: "path",
+          segments: [
+            {
+              kind: "propertySegment",
+              name: "$mel",
+              location: markerLocation
+            },
+            {
+              kind: "propertySegment",
+              name: "guards",
+              location: markerLocation
+            },
+            {
+              kind: "propertySegment",
+              name: "intent",
+              location: markerLocation
+            }
+          ],
+          location: markerLocation
+        };
+        const scopedBodyPatchStatements = this.collectPatchStatements(
+          stmt.body,
+          errors,
+          context,
+          markerScopeExpr
+        );
+        patchStatements.push(
+          {
+            patch: {
+              kind: "patch",
+              op: "set",
+              path: markerScopePath,
+              value: {
+                kind: "literal",
+                literalType: "boolean",
+                value: true,
+                location: markerLocation
+              },
+              location: markerLocation
+            },
+            condition
+          },
+          {
+            patch: {
+              kind: "patch",
+              op: "merge",
+              path: onceIntentGuardMapPath,
+              value: {
+                kind: "objectLiteral",
+                properties: [
+                  {
+                    kind: "objectProperty",
+                    key: onceIntentGuardId,
+                    value: {
+                      kind: "systemIdent",
+                      path: ["meta", "intentId"],
+                      location: markerLocation
+                    },
+                    location: markerLocation
+                  }
+                ],
+                location: markerLocation
+              },
+              location: markerLocation
+            },
+            condition: markerScopeExpr
+          },
+          ...scopedBodyPatchStatements,
+          {
+            patch: {
+              kind: "patch",
+              op: "unset",
+              path: markerScopePath,
+              location: markerLocation
+            },
+            condition
+          }
+        );
+        continue;
+      }
+      errors.push({
+        severity: "error",
+        code: "E_UNSUPPORTED_STMT",
+        message: `Unsupported statement '${stmt.kind}' in patch text. Only patch statements are allowed.`,
+        location: this.deps.mapLocation(stmt.location)
+      });
+    }
+    return patchStatements;
+  }
+};
+function compilePatchStmtToMelRuntime(patchStatement) {
+  return {
+    op: patchStatement.patch.op,
+    path: toRuntimePatchPath(patchStatement.patch.path),
+    ...patchStatement.condition ? { condition: patchStatement.condition } : void 0,
+    ...patchStatement.patch.value ? { value: toMelExpr(patchStatement.patch.value) } : void 0
+  };
+}
+function pathToMelExpr(path) {
+  const segments = path.segments;
+  let result;
+  for (const segment of segments) {
+    if (segment.kind === "propertySegment") {
+      const prop = { kind: "prop", name: segment.name };
+      if (!result) {
+        result = { kind: "get", path: [prop] };
+      } else {
+        result = {
+          kind: "call",
+          fn: "field",
+          args: [result, { kind: "lit", value: segment.name }]
+        };
+      }
+      continue;
+    }
+    if (!result) {
+      throw new Error("Path cannot start with index access in compileMelPatch guard.");
+    }
+    result = {
+      kind: "call",
+      fn: "at",
+      args: [result, toMelExpr(segment.index)]
+    };
+  }
+  if (!result) {
+    throw new Error("Empty patch guard path.");
+  }
+  return result;
+}
+function toRuntimePatchPath(path) {
+  return path.segments.map((segment) => {
+    if (segment.kind === "propertySegment") {
+      return { kind: "prop", name: segment.name };
+    }
+    return { kind: "expr", expr: toMelExpr(segment.index) };
+  });
+}
+var ConditionComposer = class {
+  and(lhs, rhs) {
+    if (!lhs) {
+      return rhs;
+    }
+    if (!rhs) {
+      return lhs;
+    }
+    return {
+      kind: "call",
+      fn: "and",
+      args: [lhs, rhs]
+    };
+  }
+};
+
+// src/api/compile-mel-patch-location.ts
+var SYNTHETIC_PATCH_PREFIX_LINES = 3;
+var SYNTHETIC_PATCH_PREFIX_COLUMNS = 6;
+function computeLineStartOffsets(lines) {
+  const offsets = [];
+  let offset = 0;
+  for (const line of lines) {
+    offsets.push(offset);
+    offset += line.length + 1;
+  }
+  return offsets;
+}
+function makePatchLocationMapper(patchLines, patchLineStarts) {
+  return (location) => remapLocationToPatchSource(location, patchLines, patchLineStarts);
+}
+function remapDiagnosticsToPatchSource(diagnostics, patchLines, patchLineStarts) {
+  return diagnostics.map((diagnostic) => remapDiagnosticToPatchSource(
+    diagnostic,
+    patchLines,
+    patchLineStarts
+  ));
+}
+function remapDiagnosticToPatchSource(diagnostic, patchLines, patchLineStarts) {
+  return {
+    ...diagnostic,
+    location: remapLocationToPatchSource(
+      diagnostic.location,
+      patchLines,
+      patchLineStarts
+    )
+  };
+}
+function remapLocationToPatchSource(location, patchLines, patchLineStarts) {
+  return {
+    ...location,
+    start: remapPositionToPatchSource(location.start, patchLines, patchLineStarts),
+    end: remapPositionToPatchSource(location.end, patchLines, patchLineStarts)
+  };
+}
+function remapPositionToPatchSource(position, patchLines, patchLineStarts) {
+  const patchLine = position.line - SYNTHETIC_PATCH_PREFIX_LINES;
+  const patchLineCount = patchLines.length;
+  const clampedPatchLine = Math.min(Math.max(patchLine, 1), patchLineCount);
+  const sourceLineStart = patchLineStarts[clampedPatchLine - 1] ?? 0;
+  const sourceLineText = patchLines[clampedPatchLine - 1] ?? "";
+  const maxSourceColumn = Math.max(sourceLineText.length + 1, 1);
+  const sourceColumn = Math.min(
+    Math.max(position.column - SYNTHETIC_PATCH_PREFIX_COLUMNS, 1),
+    maxSourceColumn
+  );
+  return {
+    line: clampedPatchLine,
+    column: sourceColumn,
+    offset: Math.max(sourceLineStart + sourceColumn - 1, 0)
+  };
+}
+
+// src/api/compile-mel-patch.ts
+var SYNTHETIC_ACTION = "__compileMelPatch";
+var SYNTHETIC_DOMAIN = "__patchDomain";
+var SYNTHETIC_PATCH_INDENT = "      ";
+function compileMelPatchText(melText, options) {
+  const trace = [];
+  const warnings = [];
+  const errors = [];
+  const patchLines = melText.split("\n");
+  const patchLineStarts = computeLineStartOffsets(patchLines);
+  const mapLocation = makePatchLocationMapper(patchLines, patchLineStarts);
+  const syntheticMel = buildSyntheticPatchProgram(melText, SYNTHETIC_ACTION);
+  const lexStart = performance.now();
+  let tokens;
+  try {
+    const lexResult = tokenize(syntheticMel);
+    tokens = lexResult.tokens;
+    const lexErrors = remapDiagnosticsToPatchSource(
+      lexResult.diagnostics.filter((d) => d.severity === "error"),
+      patchLines,
+      patchLineStarts
+    );
+    if (lexErrors.length > 0) {
+      errors.push(...lexErrors);
+      trace.push({
+        phase: "lex",
+        durationMs: performance.now() - lexStart,
+        details: { tokenCount: tokens.length }
+      });
+      return { ops: [], trace, warnings, errors };
+    }
+  } catch (error) {
+    errors.push({
+      severity: "error",
+      code: "E_LEX",
+      message: error.message,
+      location: {
+        start: { line: 1, column: 1, offset: 0 },
+        end: { line: 1, column: 1, offset: 0 }
+      }
+    });
+    trace.push({ phase: "lex", durationMs: performance.now() - lexStart });
+    return { ops: [], trace, warnings, errors };
+  }
+  trace.push({
+    phase: "lex",
+    durationMs: performance.now() - lexStart,
+    details: { tokenCount: tokens.length }
+  });
+  const parseStart = performance.now();
+  let program;
+  try {
+    const parseResult = parse(tokens);
+    const parsedDiagnostics = remapDiagnosticsToPatchSource(
+      parseResult.diagnostics,
+      patchLines,
+      patchLineStarts
+    );
+    const parseErrors = parsedDiagnostics.filter((d) => d.severity === "error");
+    const parseWarnings = parsedDiagnostics.filter((d) => d.severity !== "error");
+    if (parseErrors.length > 0) {
+      errors.push(...parseErrors);
+      warnings.push(...parseWarnings);
+      trace.push({ phase: "parse", durationMs: performance.now() - parseStart });
+      return { ops: [], trace, warnings, errors };
+    }
+    if (!parseResult.program) {
+      errors.push({
+        severity: "error",
+        code: "E_PARSE",
+        message: "Failed to parse MEL patch program",
+        location: {
+          start: { line: 1, column: 1, offset: 0 },
+          end: { line: 1, column: 1, offset: 0 }
+        }
+      });
+      warnings.push(...parseWarnings);
+      trace.push({ phase: "parse", durationMs: performance.now() - parseStart });
+      return { ops: [], trace, warnings, errors };
+    }
+    program = parseResult.program;
+    warnings.push(...parseWarnings);
+  } catch (error) {
+    errors.push({
+      severity: "error",
+      code: "E_PARSE",
+      message: error.message,
+      location: {
+        start: { line: 1, column: 1, offset: 0 },
+        end: { line: 1, column: 1, offset: 0 }
+      }
+    });
+    trace.push({ phase: "parse", durationMs: performance.now() - parseStart });
+    return { ops: [], trace, warnings, errors };
+  }
+  trace.push({ phase: "parse", durationMs: performance.now() - parseStart });
+  const analyzeStart = performance.now();
+  const collectContext = {
+    actionName: options.actionName,
+    onceCounter: 0,
+    onceIntentCounter: 0,
+    whenCounter: 0
+  };
+  const action = program.domain.members.find(
+    (member) => member.kind === "action" && member.name === SYNTHETIC_ACTION
+  );
+  if (!action) {
+    errors.push({
+      severity: "error",
+      code: "E_ANALYZE",
+      message: `Synthetic patch action '${SYNTHETIC_ACTION}' not found during parsing`,
+      location: {
+        start: { line: 1, column: 1, offset: 0 },
+        end: { line: 1, column: 1, offset: 0 }
+      }
+    });
+    trace.push({ phase: "analyze", durationMs: performance.now() - analyzeStart });
+    return { ops: [], trace, warnings, errors };
+  }
+  const expectedActionEndLine = patchLines.length + SYNTHETIC_PATCH_PREFIX_LINES + 2;
+  if (action.location.end.line !== expectedActionEndLine) {
+    errors.push({
+      severity: "error",
+      code: "E_PATCH_WRAPPER",
+      message: `Malformed synthetic patch wrapper for action '${SYNTHETIC_ACTION}'.`,
+      location: mapLocation(action.location)
+    });
+    trace.push({ phase: "analyze", durationMs: performance.now() - analyzeStart });
+    return { ops: [], trace, warnings, errors };
+  }
+  const [patchRoot] = action.body;
+  if (!patchRoot || patchRoot.kind !== "when" || !isSyntheticPatchCondition(patchRoot.condition) || action.body.length !== 1) {
+    errors.push({
+      severity: "error",
+      code: "E_PATCH_WRAPPER",
+      message: `Malformed synthetic patch wrapper for action '${SYNTHETIC_ACTION}'.`,
+      location: mapLocation(action.location)
+    });
+    trace.push({ phase: "analyze", durationMs: performance.now() - analyzeStart });
+    return { ops: [], trace, warnings, errors };
+  }
+  const collector = new PatchStatementCollector({
+    mapLocation,
+    toMelExpr
+  });
+  const patchStatements = collector.collect(
+    patchRoot.body,
+    errors,
+    collectContext,
+    void 0
+  );
+  if (errors.length === 0 && melText.trim() !== "" && patchStatements.length === 0) {
+    errors.push({
+      severity: "error",
+      code: "E_PATCH_WRAPPER",
+      message: "Patch wrapper parsing produced no patch statements. The patch source may be malformed.",
+      location: mapLocation(patchRoot.location)
+    });
+  }
+  trace.push({
+    phase: "analyze",
+    durationMs: performance.now() - analyzeStart,
+    details: { count: patchStatements.length }
+  });
+  if (errors.length > 0) {
+    return { ops: [], trace, warnings, errors };
+  }
+  const lowerStart = performance.now();
+  const loweringContext = {
+    mode: "action",
+    allowSysPaths: options.allowSysPaths ?? { prefixes: ["meta", "input"] },
+    fnTableVersion: options.fnTableVersion ?? "1.0",
+    actionName: options.actionName
+  };
+  const loweredOps = [];
+  for (const patchStatement of patchStatements) {
+    try {
+      const melPatch = compilePatchStmtToMelRuntime(patchStatement);
+      loweredOps.push(lowerRuntimePatch(melPatch, loweringContext));
+    } catch (error) {
+      if (error instanceof LoweringError) {
+        errors.push({
+          severity: "error",
+          code: error.code,
+          message: error.message,
+          location: mapLocation(patchStatement.patch.location)
+        });
+      } else if (error instanceof Error) {
+        errors.push({
+          severity: "error",
+          code: "E_LOWER",
+          message: error.message,
+          location: mapLocation(patchStatement.patch.location)
+        });
+      } else {
+        errors.push({
+          severity: "error",
+          code: "E_LOWER",
+          message: "Unknown lowering failure",
+          location: mapLocation(patchStatement.patch.location)
+        });
+      }
+    }
+  }
+  trace.push({
+    phase: "lower",
+    durationMs: performance.now() - lowerStart,
+    details: { count: loweredOps.length }
+  });
+  if (errors.length > 0) {
+    return { ops: [], trace, warnings, errors };
+  }
+  return {
+    ops: loweredOps,
+    trace,
+    warnings,
+    errors
+  };
+}
+function buildSyntheticPatchProgram(melText, actionName) {
+  const indentedPatchText = melText.split("\n").map((line) => `${SYNTHETIC_PATCH_INDENT}${line}`).join("\n");
+  return [
+    `domain ${SYNTHETIC_DOMAIN} {`,
+    `  action ${actionName}() {`,
+    "    when true {",
+    indentedPatchText,
+    "    }",
+    "  }",
+    "}"
+  ].join("\n");
+}
+
+// src/api/compile-mel.ts
+function compileMelDomain(melText, options) {
+  const trace = [];
+  const warnings = [];
+  const errors = [];
+  const lexStart = performance.now();
+  let tokens;
+  try {
+    const lexResult = tokenize(melText);
+    tokens = lexResult.tokens;
+    const lexErrors = lexResult.diagnostics.filter((d) => d.severity === "error");
+    if (lexErrors.length > 0) {
+      errors.push(...lexErrors);
+      trace.push({ phase: "lex", durationMs: performance.now() - lexStart, details: { tokenCount: tokens.length } });
+      return { schema: null, trace, warnings, errors };
+    }
+    const lexWarnings = lexResult.diagnostics.filter((d) => d.severity === "warning");
+    warnings.push(...lexWarnings);
+  } catch (e) {
+    const error = e;
+    errors.push({
+      severity: "error",
+      code: "E_LEX",
+      message: error.message,
+      location: { start: { line: 1, column: 1, offset: 0 }, end: { line: 1, column: 1, offset: 0 } }
+    });
+    trace.push({ phase: "lex", durationMs: performance.now() - lexStart });
+    return { schema: null, trace, warnings, errors };
+  }
+  trace.push({ phase: "lex", durationMs: performance.now() - lexStart, details: { tokenCount: tokens.length } });
+  const parseStart = performance.now();
+  let ast;
+  try {
+    const parseResult = parse(tokens);
+    const parseErrors = parseResult.diagnostics.filter((d) => d.severity === "error");
+    if (parseErrors.length > 0) {
+      errors.push(...parseErrors);
+      trace.push({ phase: "parse", durationMs: performance.now() - parseStart });
+      return { schema: null, trace, warnings, errors: capDiagnostics(errors) };
+    }
+    ast = parseResult.program;
+  } catch (e) {
+    const error = e;
+    errors.push({
+      severity: "error",
+      code: "E_PARSE",
+      message: error.message,
+      location: { start: { line: 1, column: 1, offset: 0 }, end: { line: 1, column: 1, offset: 0 } }
+    });
+    trace.push({ phase: "parse", durationMs: performance.now() - parseStart });
+    return { schema: null, trace, warnings, errors };
+  }
+  trace.push({ phase: "parse", durationMs: performance.now() - parseStart });
+  const analyzeStart = performance.now();
+  const scopeResult = analyzeScope(ast);
+  const validateResult = validateSemantics(ast);
+  const analyzeErrors = [
+    ...scopeResult.diagnostics.filter((d) => d.severity === "error"),
+    ...validateResult.diagnostics.filter((d) => d.severity === "error")
+  ];
+  const analyzeWarnings = [
+    ...scopeResult.diagnostics.filter((d) => d.severity === "warning"),
+    ...validateResult.diagnostics.filter((d) => d.severity === "warning")
+  ];
+  warnings.push(...analyzeWarnings);
+  trace.push({ phase: "analyze", durationMs: performance.now() - analyzeStart });
+  if (analyzeErrors.length > 0) {
+    errors.push(...analyzeErrors);
+    return { schema: null, trace, warnings, errors };
+  }
+  const genStart = performance.now();
+  const genResult = generate(ast);
+  trace.push({ phase: "generate", durationMs: performance.now() - genStart });
+  for (const diag of genResult.diagnostics) {
+    if (diag.severity === "warning") {
+      warnings.push(diag);
+    } else {
+      errors.push(diag);
+    }
+  }
+  return {
+    schema: genResult.schema,
+    trace,
+    warnings,
+    errors: capDiagnostics(errors)
+  };
+}
+var MAX_ERRORS = 10;
+function capDiagnostics(diagnostics) {
+  if (diagnostics.length <= MAX_ERRORS) return diagnostics;
+  const capped = diagnostics.slice(0, MAX_ERRORS);
+  capped.push({
+    severity: "error",
+    code: "E_TOO_MANY",
+    message: `... and ${diagnostics.length - MAX_ERRORS} more error(s). Fix the errors above first.`,
+    location: { start: { line: 0, column: 0, offset: 0 }, end: { line: 0, column: 0, offset: 0 } }
+  });
+  return capped;
+}
+function compileMelPatch(melText, options) {
+  return compileMelPatchText(melText, options);
+}
+
+export {
+  KEYWORDS,
+  RESERVED_KEYWORDS,
+  isKeyword,
+  isReserved,
+  getKeywordKind,
+  createToken,
+  createPosition,
+  createLocation,
+  createPointLocation,
+  mergeLocations,
+  Lexer,
+  tokenize,
+  isExprNode,
+  isStmtNode,
+  Precedence,
+  getBinaryPrecedence,
+  tokenToBinaryOp,
+  isBinaryOp,
+  isUnaryOp,
+  isRightAssociative,
+  Parser,
+  parse,
+  Scope,
+  ScopeAnalyzer,
+  analyzeScope,
+  createError,
+  createWarning,
+  createInfo,
+  isError,
+  hasErrors,
+  filterBySeverity,
+  SemanticValidator,
+  validateSemantics,
+  normalizeExpr,
+  normalizeFunctionCall,
+  generate,
+  LoweringError,
+  invalidKindForContext,
+  unknownCallFn,
+  invalidSysPath,
+  unsupportedBase,
+  invalidShape,
+  unknownNodeKind,
+  lowerExprNode,
+  lowerRuntimePatches,
+  lowerRuntimePatch,
+  compileMelDomain,
+  compileMelPatch
+};
+//# sourceMappingURL=chunk-QP2LGMBA.js.map