@manifesto-ai/compiler 1.6.2 → 1.8.0

package/dist/index.d.ts

@@ -1,17 +1,2816 @@
+import { ExprNode as ExprNode$2, PatchPath, Patch } from '@manifesto-ai/core';
+
+/**
+ * Source Location Types
+ * Tracks positions in MEL source code for error reporting
+ */
+/**
+ * A position in source code (1-based line/column)
+ */
+interface Position {
+    /** 1-based line number */
+    line: number;
+    /** 1-based column number */
+    column: number;
+    /** 0-based byte offset from start of source */
+    offset: number;
+}
+/**
+ * A span in source code (start to end)
+ */
+interface SourceLocation {
+    start: Position;
+    end: Position;
+    /** Optional source file path */
+    source?: string;
+}
+/**
+ * Create a position
+ */
+declare function createPosition(line: number, column: number, offset: number): Position;
+/**
+ * Create a source location from two positions
+ */
+declare function createLocation(start: Position, end: Position, source?: string): SourceLocation;
+/**
+ * Create a zero-width location at a position
+ */
+declare function createPointLocation(pos: Position, source?: string): SourceLocation;
+/**
+ * Merge two locations into one spanning both
+ */
+declare function mergeLocations(a: SourceLocation, b: SourceLocation): SourceLocation;
+
+/**
+ * Token Types for MEL Lexer
+ * Based on MEL SPEC v0.3.3 Section 3
+ */
+
+/**
+ * All token kinds in MEL
+ */
+type TokenKind = "DOMAIN" | "STATE" | "COMPUTED" | "ACTION" | "EFFECT" | "WHEN" | "ONCE" | "PATCH" | "UNSET" | "MERGE" | "TRUE" | "FALSE" | "NULL" | "AS" | "AVAILABLE" | "FAIL" | "STOP" | "WITH" | "TYPE" | "IMPORT" | "FROM" | "EXPORT" | "PLUS" | "MINUS" | "STAR" | "SLASH" | "PERCENT" | "EQ_EQ" | "BANG_EQ" | "LT" | "LT_EQ" | "GT" | "GT_EQ" | "AMP_AMP" | "PIPE_PIPE" | "BANG" | "QUESTION_QUESTION" | "QUESTION" | "COLON" | "EQ" | "LPAREN" | "RPAREN" | "LBRACE" | "RBRACE" | "LBRACKET" | "RBRACKET" | "COMMA" | "SEMICOLON" | "DOT" | "PIPE" | "NUMBER" | "STRING" | "IDENTIFIER" | "SYSTEM_IDENT" | "ITEM" | "EOF" | "ERROR";
+/**
+ * A token produced by the lexer
+ */
+interface Token {
+    kind: TokenKind;
+    /** The raw text of the token */
+    lexeme: string;
+    /** Parsed value for literals */
+    value?: unknown;
+    /** Location in source */
+    location: SourceLocation;
+}
+/**
+ * Keywords lookup table
+ */
+declare const KEYWORDS: Record<string, TokenKind>;
+/**
+ * Reserved keywords (JS keywords that are forbidden in MEL)
+ */
+declare const RESERVED_KEYWORDS: Set<string>;
+/**
+ * Check if a token is a keyword
+ */
+declare function isKeyword(lexeme: string): boolean;
+/**
+ * Check if a token is a reserved word
+ */
+declare function isReserved(lexeme: string): boolean;
+/**
+ * Get keyword token kind, or undefined if not a keyword
+ * Note: Uses Object.hasOwn to avoid prototype pollution (e.g., "toString")
+ */
+declare function getKeywordKind(lexeme: string): TokenKind | undefined;
+/**
+ * Create a token
+ */
+declare function createToken(kind: TokenKind, lexeme: string, location: SourceLocation, value?: unknown): Token;
+
+/**
+ * Diagnostic Types for MEL Compiler
+ * Error and warning reporting structures
+ */
+
+/**
+ * Severity level of a diagnostic
+ */
+type DiagnosticSeverity = "error" | "warning" | "info";
+/**
+ * A diagnostic message (error, warning, or info)
+ */
+interface Diagnostic {
+    /** Severity level */
+    severity: DiagnosticSeverity;
+    /** Error code (e.g., "MEL001", "MEL_LEXER") */
+    code: string;
+    /** Human-readable message */
+    message: string;
+    /** Location in source */
+    location: SourceLocation;
+    /** The source line containing the error */
+    source?: string;
+    /** Suggested fix */
+    suggestion?: string;
+    /** Related diagnostics */
+    related?: RelatedDiagnostic[];
+}
+/**
+ * A related diagnostic (for multi-location errors)
+ */
+interface RelatedDiagnostic {
+    message: string;
+    location: SourceLocation;
+}
+/**
+ * Create an error diagnostic
+ */
+declare function createError(code: string, message: string, location: SourceLocation, options?: {
+    source?: string;
+    suggestion?: string;
+    related?: RelatedDiagnostic[];
+}): Diagnostic;
+/**
+ * Create a warning diagnostic
+ */
+declare function createWarning(code: string, message: string, location: SourceLocation, options?: {
+    source?: string;
+    suggestion?: string;
+}): Diagnostic;
+/**
+ * Create an info diagnostic
+ */
+declare function createInfo(code: string, message: string, location: SourceLocation): Diagnostic;
+/**
+ * Check if a diagnostic is an error
+ */
+declare function isError(diagnostic: Diagnostic): boolean;
+/**
+ * Check if any diagnostics contain errors
+ */
+declare function hasErrors(diagnostics: Diagnostic[]): boolean;
+/**
+ * Filter diagnostics by severity
+ */
+declare function filterBySeverity(diagnostics: Diagnostic[], severity: DiagnosticSeverity): Diagnostic[];
+
+/**
+ * MEL Lexer
+ * Tokenizes MEL source code based on SPEC v0.3.1 Section 3
+ */
+
+/**
+ * Result of lexical analysis
+ */
+interface LexResult {
+    tokens: Token[];
+    diagnostics: Diagnostic[];
+}
+/**
+ * Lexer for MEL source code
+ */
+declare class Lexer {
+    private source;
+    private sourcePath?;
+    private tokens;
+    private diagnostics;
+    private start;
+    private current;
+    private line;
+    private column;
+    private lineStart;
+    constructor(source: string, sourcePath?: string);
+    /**
+     * Tokenize the source code
+     */
+    tokenize(): LexResult;
+    private scanToken;
+    private lineComment;
+    private blockComment;
+    private string;
+    private number;
+    private identifier;
+    private systemIdentifier;
+    private isAtEnd;
+    private advance;
+    private peek;
+    private peekNext;
+    private match;
+    private newline;
+    private isDigit;
+    private isHexDigit;
+    private isAlpha;
+    private isAlphaNumeric;
+    private currentLocation;
+    private positionAt;
+    private addToken;
+    private error;
+    private getSourceLine;
+}
+/**
+ * Tokenize MEL source code
+ */
+declare function tokenize(source: string, sourcePath?: string): LexResult;
+
+/**
+ * AST Node Types for MEL Parser
+ * Based on MEL SPEC v0.3.3 Section 4
+ */
+
+/**
+ * Base interface for all AST nodes
+ */
+interface ASTNode {
+    location: SourceLocation;
+}
+/**
+ * Root node of a MEL program
+ */
+interface ProgramNode extends ASTNode {
+    kind: "program";
+    imports: ImportNode[];
+    domain: DomainNode;
+}
+/**
+ * Import declaration
+ */
+interface ImportNode extends ASTNode {
+    kind: "import";
+    names: string[];
+    from: string;
+}
+/**
+ * Domain declaration
+ */
+interface DomainNode extends ASTNode {
+    kind: "domain";
+    name: string;
+    /** v0.3.3: Named type declarations */
+    types: TypeDeclNode[];
+    members: DomainMember[];
+}
+/**
+ * Domain member types
+ */
+type DomainMember = StateNode | ComputedNode | ActionNode | FlowDeclNode;
+/**
+ * Type declaration (v0.3.3)
+ * Syntax: type Name = TypeExpr
+ */
+interface TypeDeclNode extends ASTNode {
+    kind: "typeDecl";
+    name: string;
+    typeExpr: TypeExprNode;
+}
+/**
+ * State block declaration
+ */
+interface StateNode extends ASTNode {
+    kind: "state";
+    fields: StateFieldNode[];
+}
+/**
+ * State field declaration
+ */
+interface StateFieldNode extends ASTNode {
+    kind: "stateField";
+    name: string;
+    typeExpr: TypeExprNode;
+    initializer?: ExprNode$1;
+}
+/**
+ * Computed value declaration
+ */
+interface ComputedNode extends ASTNode {
+    kind: "computed";
+    name: string;
+    expression: ExprNode$1;
+}
+/**
+ * Action declaration
+ */
+interface ActionNode extends ASTNode {
+    kind: "action";
+    name: string;
+    params: ParamNode[];
+    /** v0.3.2: Optional availability condition */
+    available?: ExprNode$1;
+    body: GuardedStmtNode[];
+}
+/**
+ * Flow declaration (v0.7.0 / ADR-013a)
+ * Raw AST preserves flow declarations until the expansion pass removes them.
+ */
+interface FlowDeclNode extends ASTNode {
+    kind: "flow";
+    name: string;
+    params: ParamNode[];
+    body: FlowStmtNode[];
+}
+/**
+ * Parameter declaration
+ */
+interface ParamNode extends ASTNode {
+    kind: "param";
+    name: string;
+    typeExpr: TypeExprNode;
+}
+/**
+ * Guarded statement types (top-level in action body)
+ */
+type GuardedStmtNode = WhenStmtNode | OnceStmtNode | OnceIntentStmtNode | IncludeStmtNode | FailStmtNode | StopStmtNode;
+/**
+ * Raw flow statement types (top-level in flow body).
+ * Parser stays permissive; validation narrows the allowed subset.
+ */
+type FlowStmtNode = WhenStmtNode | IncludeStmtNode | OnceStmtNode | OnceIntentStmtNode | PatchStmtNode | EffectStmtNode;
+/**
+ * Inner statement types (inside guards)
+ */
+type InnerStmtNode = PatchStmtNode | EffectStmtNode | WhenStmtNode | OnceStmtNode | OnceIntentStmtNode | IncludeStmtNode | FailStmtNode | StopStmtNode;
+/**
+ * When guard statement
+ */
+interface WhenStmtNode extends ASTNode {
+    kind: "when";
+    condition: ExprNode$1;
+    body: InnerStmtNode[];
+}
+/**
+ * Once guard statement (per-intent idempotency)
+ */
+interface OnceStmtNode extends ASTNode {
+    kind: "once";
+    marker: PathNode;
+    condition?: ExprNode$1;
+    body: InnerStmtNode[];
+}
+/**
+ * Once-intent guard statement (per-intent idempotency sugar)
+ */
+interface OnceIntentStmtNode extends ASTNode {
+    kind: "onceIntent";
+    condition?: ExprNode$1;
+    body: InnerStmtNode[];
+}
+/**
+ * Include statement (v0.7.0 / ADR-013a)
+ * Raw AST preserves include sites until the expansion pass inlines them.
+ */
+interface IncludeStmtNode extends ASTNode {
+    kind: "include";
+    flowName: string;
+    args: ExprNode$1[];
+}
+/**
+ * Patch statement
+ */
+interface PatchStmtNode extends ASTNode {
+    kind: "patch";
+    path: PathNode;
+    op: "set" | "unset" | "merge";
+    value?: ExprNode$1;
+}
+/**
+ * Effect statement
+ */
+interface EffectStmtNode extends ASTNode {
+    kind: "effect";
+    effectType: string;
+    args: EffectArgNode[];
+}
+/**
+ * Effect argument
+ */
+interface EffectArgNode extends ASTNode {
+    kind: "effectArg";
+    name: string;
+    value: ExprNode$1 | PathNode;
+    isPath: boolean;
+}
+/**
+ * Fail statement (v0.3.2) - terminates flow with error
+ * Compiles to FlowNode { kind: "fail", code, message }
+ */
+interface FailStmtNode extends ASTNode {
+    kind: "fail";
+    code: string;
+    message?: ExprNode$1;
+}
+/**
+ * Stop statement (v0.3.2) - early exit, no error
+ * Compiles to FlowNode { kind: "halt", reason }
+ */
+interface StopStmtNode extends ASTNode {
+    kind: "stop";
+    reason: string;
+}
+/**
+ * Type expression node
+ */
+type TypeExprNode = SimpleTypeNode | UnionTypeNode | ArrayTypeNode | RecordTypeNode | LiteralTypeNode | ObjectTypeNode;
+interface SimpleTypeNode extends ASTNode {
+    kind: "simpleType";
+    name: string;
+}
+interface UnionTypeNode extends ASTNode {
+    kind: "unionType";
+    types: TypeExprNode[];
+}
+interface ArrayTypeNode extends ASTNode {
+    kind: "arrayType";
+    elementType: TypeExprNode;
+}
+interface RecordTypeNode extends ASTNode {
+    kind: "recordType";
+    keyType: TypeExprNode;
+    valueType: TypeExprNode;
+}
+interface LiteralTypeNode extends ASTNode {
+    kind: "literalType";
+    value: string | number | boolean | null;
+}
+/**
+ * Object type node (v0.3.3)
+ * Represents inline object types: { field: Type, ... }
+ * Note: In state fields, this triggers W012 warning (use named type instead)
+ */
+interface ObjectTypeNode extends ASTNode {
+    kind: "objectType";
+    fields: TypeFieldNode[];
+}
+/**
+ * Type field within an object type
+ */
+interface TypeFieldNode extends ASTNode {
+    kind: "typeField";
+    name: string;
+    typeExpr: TypeExprNode;
+    optional: boolean;
+}
+/**
+ * All expression types
+ */
+type ExprNode$1 = LiteralExprNode | IdentifierExprNode | SystemIdentExprNode | IterationVarExprNode | PropertyAccessExprNode | IndexAccessExprNode | FunctionCallExprNode | UnaryExprNode | BinaryExprNode | TernaryExprNode | ObjectLiteralExprNode | ArrayLiteralExprNode;
+/**
+ * Literal expression (number, string, boolean, null)
+ */
+interface LiteralExprNode extends ASTNode {
+    kind: "literal";
+    value: unknown;
+    literalType: "number" | "string" | "boolean" | "null";
+}
+/**
+ * Identifier expression
+ */
+interface IdentifierExprNode extends ASTNode {
+    kind: "identifier";
+    name: string;
+}
+/**
+ * System identifier expression ($system.*, $meta.*, $input.*)
+ */
+interface SystemIdentExprNode extends ASTNode {
+    kind: "systemIdent";
+    path: string[];
+}
+/**
+ * Iteration variable expression ($item only)
+ * v0.3.2: $acc removed - reduce pattern deprecated
+ */
+interface IterationVarExprNode extends ASTNode {
+    kind: "iterationVar";
+    name: "item";
+}
+/**
+ * Property access expression (a.b)
+ */
+interface PropertyAccessExprNode extends ASTNode {
+    kind: "propertyAccess";
+    object: ExprNode$1;
+    property: string;
+}
+/**
+ * Index access expression (a[b])
+ */
+interface IndexAccessExprNode extends ASTNode {
+    kind: "indexAccess";
+    object: ExprNode$1;
+    index: ExprNode$1;
+}
+/**
+ * Function call expression
+ */
+interface FunctionCallExprNode extends ASTNode {
+    kind: "functionCall";
+    name: string;
+    args: ExprNode$1[];
+}
+/**
+ * Unary expression (!a, -a)
+ */
+interface UnaryExprNode extends ASTNode {
+    kind: "unary";
+    operator: "!" | "-";
+    operand: ExprNode$1;
+}
+/**
+ * Binary operators
+ */
+type BinaryOperator = "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "&&" | "||" | "??";
+/**
+ * Binary expression (a + b, a && b, etc.)
+ */
+interface BinaryExprNode extends ASTNode {
+    kind: "binary";
+    operator: BinaryOperator;
+    left: ExprNode$1;
+    right: ExprNode$1;
+}
+/**
+ * Ternary expression (a ? b : c)
+ */
+interface TernaryExprNode extends ASTNode {
+    kind: "ternary";
+    condition: ExprNode$1;
+    consequent: ExprNode$1;
+    alternate: ExprNode$1;
+}
+/**
+ * Object literal expression ({ a: 1, b: 2 })
+ */
+interface ObjectLiteralExprNode extends ASTNode {
+    kind: "objectLiteral";
+    properties: ObjectPropertyNode[];
+}
+interface ObjectPropertyNode extends ASTNode {
+    kind: "objectProperty";
+    key: string;
+    value: ExprNode$1;
+}
+/**
+ * Array literal expression ([1, 2, 3])
+ */
+interface ArrayLiteralExprNode extends ASTNode {
+    kind: "arrayLiteral";
+    elements: ExprNode$1[];
+}
+/**
+ * Path node for patch targets and effect destinations
+ */
+interface PathNode extends ASTNode {
+    kind: "path";
+    segments: PathSegmentNode[];
+}
+type PathSegmentNode = PropertySegmentNode | IndexSegmentNode;
+interface PropertySegmentNode extends ASTNode {
+    kind: "propertySegment";
+    name: string;
+}
+interface IndexSegmentNode extends ASTNode {
+    kind: "indexSegment";
+    index: ExprNode$1;
+}
+/**
+ * Check if a node is an expression
+ */
+declare function isExprNode(node: ASTNode): node is ExprNode$1;
+/**
+ * Check if a node is a statement
+ */
+declare function isStmtNode(node: ASTNode): node is InnerStmtNode;
+
+/**
+ * Operator Precedence for MEL Parser
+ * Based on MEL SPEC v0.3.1 Section 4.9
+ */
+
+/**
+ * Precedence levels (higher = binds tighter)
+ */
+declare const enum Precedence {
+    NONE = 0,
+    TERNARY = 1,// ? :
+    NULLISH = 2,// ??
+    OR = 3,// ||
+    AND = 4,// &&
+    EQUALITY = 5,// == !=
+    COMPARISON = 6,// < <= > >=
+    ADDITIVE = 7,// + -
+    MULTIPLICATIVE = 8,// * / %
+    UNARY = 9,// ! -
+    CALL = 10,// ()
+    ACCESS = 11
+}
+/**
+ * Get the precedence of a binary operator token
+ */
+declare function getBinaryPrecedence(kind: TokenKind): Precedence;
+/**
+ * Map token kind to binary operator
+ */
+declare function tokenToBinaryOp(kind: TokenKind): BinaryOperator | null;
+/**
+ * Check if a token is a binary operator
+ */
+declare function isBinaryOp(kind: TokenKind): boolean;
+/**
+ * Check if a token is a unary operator
+ */
+declare function isUnaryOp(kind: TokenKind): boolean;
+/**
+ * Check if operators are right-associative
+ */
+declare function isRightAssociative(kind: TokenKind): boolean;
+
+/**
+ * MEL Parser
+ * Recursive descent parser with Pratt parsing for expressions
+ * Based on MEL SPEC v0.3.3 Section 4
+ */
+
+/**
+ * Result of parsing
+ */
+interface ParseResult {
+    program: ProgramNode | null;
+    diagnostics: Diagnostic[];
+}
+/**
+ * Parser for MEL source code
+ */
+declare class Parser {
+    private tokens;
+    private current;
+    private diagnostics;
+    constructor(tokens: Token[]);
+    /**
+     * Parse tokens into an AST
+     */
+    parse(): ParseResult;
+    private parseProgram;
+    private parseImport;
+    private parseDomain;
+    /**
+     * v0.3.3: Parse type declaration
+     * Syntax: type Name = TypeExpr
+     */
+    private parseTypeDecl;
+    private parseDomainMember;
+    private parseState;
+    private parseStateField;
+    private parseComputed;
+    private parseAction;
+    private parseFlowDecl;
+    private parseParam;
+    private parseGuardedStmt;
+    private parseFlowStmt;
+    /**
+     * Skip tokens until we reach a recovery point (closing brace, guard keyword, or EOF).
+     */
+    private skipToRecoveryPoint;
+    private parseWhenStmt;
+    private parseOnceStmt;
+    private parseOnceIntentStmt;
+    private parseInnerStmt;
+    private parseIncludeStmt;
+    private parsePatchStmt;
+    private parseEffectStmt;
+    private parseEffectArg;
+    /**
+     * v0.3.2: Parse fail statement
+     * FailStmt ::= 'fail' StringLiteral ('with' Expr)?
+     */
+    private parseFailStmt;
+    /**
+     * v0.3.2: Parse stop statement
+     * StopStmt ::= 'stop' StringLiteral
+     */
+    private parseStopStmt;
+    private parseTypeExpr;
+    private parseBaseType;
+    /**
+     * v0.3.3: Parse object type
+     * Syntax: { field: Type, field?: Type, ... }
+     */
+    private parseObjectType;
+    private parseExpression;
+    private parseTernary;
+    private parsePrimary;
+    private parseFunctionCall;
+    private parsePostfix;
+    private parseObjectLiteral;
+    private parseArrayLiteral;
+    private parsePath;
+    private isUnaryContext;
+    private peek;
+    private peekNext;
+    private peekAt;
+    private previous;
+    private isAtEnd;
+    private advance;
+    private check;
+    private isOnceIntentContext;
+    private isFlowDeclContext;
+    private isIncludeContext;
+    private match;
+    private consume;
+    private error;
+    private errorAtCurrent;
+}
+/**
+ * Parse tokens into an AST
+ */
+declare function parse(tokens: Token[]): ParseResult;
+
+/**
+ * Scope Analysis for MEL
+ * Tracks variable scopes and resolves identifiers
+ * Based on MEL SPEC v0.3.1 Section 4.10
+ */
+
+/**
+ * Symbol kinds
+ */
+type SymbolKind = "state" | "computed" | "param" | "action" | "iteration";
+/**
+ * Symbol information
+ */
+interface Symbol {
+    name: string;
+    kind: SymbolKind;
+    location: SourceLocation;
+    type?: string;
+}
+/**
+ * Scope represents a lexical scope
+ */
+declare class Scope {
+    readonly parent: Scope | null;
+    readonly symbols: Map<string, Symbol>;
+    readonly kind: "domain" | "action" | "guard";
+    constructor(kind: "domain" | "action" | "guard", parent?: Scope | null);
+    /**
+     * Define a new symbol in this scope
+     */
+    define(symbol: Symbol): void;
+    /**
+     * Look up a symbol, searching parent scopes if not found
+     */
+    lookup(name: string): Symbol | undefined;
+    /**
+     * Check if a symbol is defined in this scope (not parent scopes)
+     */
+    isDefined(name: string): boolean;
+}
+/**
+ * Result of scope analysis
+ */
+interface ScopeAnalysisResult {
+    scopes: Map<string, Scope>;
+    diagnostics: Diagnostic[];
+}
+/**
+ * Scope Analyzer - builds scope tree and checks for errors
+ */
+declare class ScopeAnalyzer {
+    private diagnostics;
+    private scopes;
+    private currentScope;
+    private domainScope;
+    /**
+     * Analyze a MEL program
+     */
+    analyze(program: ProgramNode): ScopeAnalysisResult;
+    private analyzeDomain;
+    private analyzeComputedExpr;
+    private analyzeAction;
+    private analyzeStmt;
+    private analyzeExpr;
+    private checkIdentifier;
+    private checkSystemIdent;
+    private validatePath;
+    private defineSymbol;
+    private error;
+}
+/**
+ * Analyze a MEL program for scope issues
+ */
+declare function analyzeScope(program: ProgramNode): ScopeAnalysisResult;
+
+/**
+ * Semantic Validator for MEL
+ * Validates semantic rules beyond syntax
+ * Based on MEL SPEC v0.3.3 and FDR-MEL-*
+ */
+
+/**
+ * Result of semantic validation
+ */
+interface ValidationResult {
+    valid: boolean;
+    diagnostics: Diagnostic[];
+}
+/**
+ * Semantic Validator
+ */
+declare class SemanticValidator {
+    private ctx;
+    private symbols;
+    /**
+     * Validate a MEL program
+     */
+    validate(program: ProgramNode): ValidationResult;
+    private validateDomain;
+    /**
+     * v0.3.3: Validate state fields for W012 (anonymous object types)
+     */
+    private validateState;
+    /**
+     * v0.3.3: Validate state field - check for anonymous object types (W012)
+     */
+    private validateStateField;
+    private validateStateInitializer;
+    /**
+     * v0.3.3: Check if a type expression contains anonymous object types
+     * Issues W012 warning for inline object types in state fields
+     */
+    private checkAnonymousObjectType;
+    private validateAction;
+    /**
+     * v0.3.3: Validate available expression is pure (E005)
+     * No $system.*, no effects, no $input.*
+     */
+    private validateAvailableExpr;
+    private validateGuardedStmt;
+    private validateWhen;
+    private validateOnce;
+    private validateOnceIntent;
+    private validatePatch;
+    private validateEffect;
+    private validateFail;
+    private validateStop;
+    private validateCondition;
+    private validateExpr;
+    private validateFunctionCall;
+    private validatePrimitiveEquality;
+    private error;
+    private warn;
+}
+/**
+ * Validate a MEL program semantically
+ */
+declare function validateSemantics(program: ProgramNode): ValidationResult;
+
+/**
+ * MEL Compiler Diagnostic Codes
+ * Based on MEL SPEC v0.3.3 Appendix A
+ */
+/**
+ * Diagnostic code information
+ */
+interface DiagnosticCode {
+    code: string;
+    message: string;
+    category: "syntax" | "semantic" | "type" | "system";
+}
+/**
+ * All diagnostic codes
+ */
+declare const DIAGNOSTIC_CODES: Record<string, DiagnosticCode>;
+/**
+ * Get diagnostic code information
+ */
+declare function getDiagnosticInfo(code: string): DiagnosticCode | undefined;
+/**
+ * Format a diagnostic code for display
+ */
+declare function formatDiagnosticCode(code: string): string;
+
+/**
+ * Plain-text Diagnostic Formatter
+ *
+ * Browser-safe (no ANSI colors). Produces human-readable error messages
+ * with optional source context and caret indicators.
+ *
+ * @module
+ */
+
+/**
+ * Format a single diagnostic as plain text.
+ *
+ * Without source: `[MEL_PARSER] Expected '{' (3:15)`
+ * With source:
+ * ```
+ * [MEL_PARSER] Expected '{' (3:15)
+ *    3 | domain Bad bad syntax here }
+ *                ^^^
+ * ```
+ */
+declare function formatDiagnostic(diagnostic: Diagnostic, source?: string): string;
+/**
+ * Format multiple diagnostics, separated by blank lines.
+ */
+declare function formatDiagnostics(diagnostics: Diagnostic[], source?: string): string;
+
+/**
+ * Lowering Context Types
+ *
+ * Defines contexts for expression and patch lowering.
+ *
+ * @see SPEC v0.4.0 §17.2
+ */
+/**
+ * Allowed system path prefixes.
+ *
+ * In Translator path, only 'meta' and 'input' are allowed.
+ * 'system' is forbidden (requires Flow execution).
+ *
+ * @see FDR-MEL-071
+ */
+type AllowedSysPrefix = "meta" | "input";
+/**
+ * Context for single expression lowering.
+ *
+ * @see SPEC v0.4.0 §17.2
+ */
+interface ExprLoweringContext {
+    /**
+     * Expression context mode.
+     * - 'schema': for addComputed, addConstraint, etc.
+     * - 'action': for guards, patches, effects
+     */
+    mode: "schema" | "action";
+    /**
+     * Allowed system path prefixes.
+     * In Translator path: only ["meta", "input"]
+     *
+     * @see FDR-MEL-071
+     */
+    allowSysPaths?: {
+        prefixes: AllowedSysPrefix[];
+    };
+    /**
+     * Function table version for call lowering.
+     */
+    fnTableVersion: string;
+    /**
+     * Action name (for action context).
+     */
+    actionName?: string;
+    /**
+     * Whether $item is allowed in this context.
+     * Only true for effect.args fields.
+     *
+     * @see FDR-MEL-068
+     */
+    allowItem?: boolean;
+}
+/**
+ * Context for patch lowering.
+ *
+ * NO mode field - Compiler determines context per op-field.
+ *
+ * @see SPEC v0.4.0 §17.2, AD-COMP-LOW-002
+ */
+interface PatchLoweringContext {
+    /**
+     * Allowed system path prefixes.
+     * In Translator path: only ["meta", "input"]
+     *
+     * @see FDR-MEL-071
+     */
+    allowSysPaths?: {
+        prefixes: AllowedSysPrefix[];
+    };
+    /**
+     * Function table version for call lowering.
+     */
+    fnTableVersion: string;
+    /**
+     * Action name (for action-related ops).
+     */
+    actionName?: string;
+}
+/**
+ * Default expression lowering context for schema mode.
+ */
+declare const DEFAULT_SCHEMA_CONTEXT: ExprLoweringContext;
+/**
+ * Default expression lowering context for action mode.
+ */
+declare const DEFAULT_ACTION_CONTEXT: ExprLoweringContext;
+/**
+ * Context for effect.args (allows $item).
+ */
+declare const EFFECT_ARGS_CONTEXT: ExprLoweringContext;
+/**
+ * Default patch lowering context.
+ */
+declare const DEFAULT_PATCH_CONTEXT: PatchLoweringContext;
+
+/**
+ * Expression Lowering
+ *
+ * Transforms MEL Canonical IR (8 kinds) to Core Runtime IR (30+ kinds).
+ *
+ * @see SPEC v0.4.0 §17
+ */
+
+/**
+ * MEL primitive value.
+ */
+type MelPrimitive = null | boolean | number | string;
+/**
+ * MEL path segment.
+ */
+type MelPathSegment = {
+    kind: "prop";
+    name: string;
+};
+/**
+ * MEL path node array.
+ */
+type MelPathNode = MelPathSegment[];
+/**
+ * MEL system path as segment array.
+ */
+type MelSystemPath = string[];
+/**
+ * MEL object field.
+ */
+type MelObjField = {
+    key: string;
+    value: MelExprNode;
+};
+/**
+ * MEL Canonical IR (8 kinds).
+ *
+ * @see SPEC v0.4.0 §17.1.1
+ */
+type MelExprNode = {
+    kind: "lit";
+    value: MelPrimitive;
+} | {
+    kind: "var";
+    name: "item";
+} | {
+    kind: "sys";
+    path: MelSystemPath;
+} | {
+    kind: "get";
+    base?: MelExprNode;
+    path: MelPathNode;
+} | {
+    kind: "field";
+    object: MelExprNode;
+    property: string;
+} | {
+    kind: "call";
+    fn: string;
+    args: MelExprNode[];
+} | {
+    kind: "obj";
+    fields: MelObjField[];
+} | {
+    kind: "arr";
+    elements: MelExprNode[];
+};
+/**
+ * Lower MEL expression to Core expression.
+ *
+ * @param input - MEL canonical IR expression
+ * @param ctx - Lowering context
+ * @returns Core runtime IR expression
+ * @throws LoweringError if expression cannot be lowered
+ *
+ * @see SPEC v0.4.0 §17.3
+ */
+declare function lowerExprNode(input: MelExprNode, ctx: ExprLoweringContext): ExprNode$2;
+
+/**
+ * IR Generator - Transforms MEL AST to Core DomainSchema
+ * Based on MEL SPEC v0.3.3 Section 5
+ */
+
+/**
+ * Core ExprNode types (simplified, matching core/schema/expr.ts)
+ */
+type CoreExprNode = {
+    kind: "lit";
+    value: unknown;
+} | {
+    kind: "get";
+    path: string;
+} | {
+    kind: "eq";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "neq";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "gt";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "gte";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "lt";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "lte";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "and";
+    args: CoreExprNode[];
+} | {
+    kind: "or";
+    args: CoreExprNode[];
+} | {
+    kind: "not";
+    arg: CoreExprNode;
+} | {
+    kind: "if";
+    cond: CoreExprNode;
+    then: CoreExprNode;
+    else: CoreExprNode;
+} | {
+    kind: "add";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "sub";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "mul";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "div";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "mod";
+    left: CoreExprNode;
+    right: CoreExprNode;
+} | {
+    kind: "neg";
+    arg: CoreExprNode;
+} | {
+    kind: "abs";
+    arg: CoreExprNode;
+} | {
+    kind: "min";
+    args: CoreExprNode[];
+} | {
+    kind: "max";
+    args: CoreExprNode[];
+} | {
+    kind: "sumArray";
+    array: CoreExprNode;
+} | {
+    kind: "minArray";
+    array: CoreExprNode;
+} | {
+    kind: "maxArray";
+    array: CoreExprNode;
+} | {
+    kind: "floor";
+    arg: CoreExprNode;
+} | {
+    kind: "ceil";
+    arg: CoreExprNode;
+} | {
+    kind: "round";
+    arg: CoreExprNode;
+} | {
+    kind: "sqrt";
+    arg: CoreExprNode;
+} | {
+    kind: "pow";
+    base: CoreExprNode;
+    exponent: CoreExprNode;
+} | {
+    kind: "concat";
+    args: CoreExprNode[];
+} | {
+    kind: "trim";
+    str: CoreExprNode;
+} | {
+    kind: "toLowerCase";
+    str: CoreExprNode;
+} | {
+    kind: "toUpperCase";
+    str: CoreExprNode;
+} | {
+    kind: "strLen";
+    str: CoreExprNode;
+} | {
+    kind: "substring";
+    str: CoreExprNode;
+    start: CoreExprNode;
+    end?: CoreExprNode;
+} | {
+    kind: "len";
+    arg: CoreExprNode;
+} | {
+    kind: "at";
+    array: CoreExprNode;
+    index: CoreExprNode;
+} | {
+    kind: "first";
+    array: CoreExprNode;
+} | {
+    kind: "last";
+    array: CoreExprNode;
+} | {
+    kind: "slice";
+    array: CoreExprNode;
+    start: CoreExprNode;
+    end?: CoreExprNode;
+} | {
+    kind: "includes";
+    array: CoreExprNode;
+    item: CoreExprNode;
+} | {
+    kind: "filter";
+    array: CoreExprNode;
+    predicate: CoreExprNode;
+} | {
+    kind: "map";
+    array: CoreExprNode;
+    mapper: CoreExprNode;
+} | {
+    kind: "find";
+    array: CoreExprNode;
+    predicate: CoreExprNode;
+} | {
+    kind: "every";
+    array: CoreExprNode;
+    predicate: CoreExprNode;
+} | {
+    kind: "some";
+    array: CoreExprNode;
+    predicate: CoreExprNode;
+} | {
+    kind: "append";
+    array: CoreExprNode;
+    items: CoreExprNode[];
+} | {
+    kind: "object";
+    fields: Record<string, CoreExprNode>;
+} | {
+    kind: "field";
+    object: CoreExprNode;
+    property: string;
+} | {
+    kind: "keys";
+    obj: CoreExprNode;
+} | {
+    kind: "values";
+    obj: CoreExprNode;
+} | {
+    kind: "entries";
+    obj: CoreExprNode;
+} | {
+    kind: "merge";
+    objects: CoreExprNode[];
+} | {
+    kind: "typeof";
+    arg: CoreExprNode;
+} | {
+    kind: "isNull";
+    arg: CoreExprNode;
+} | {
+    kind: "coalesce";
+    args: CoreExprNode[];
+} | {
+    kind: "toString";
+    arg: CoreExprNode;
+};
+type CompilerExprNode = MelExprNode;
+/**
+ * Core FlowNode types (matching core/schema/flow.ts)
+ */
+type CoreFlowNode = {
+    kind: "seq";
+    steps: CoreFlowNode[];
+} | {
+    kind: "if";
+    cond: CoreExprNode;
+    then: CoreFlowNode;
+    else?: CoreFlowNode;
+} | {
+    kind: "patch";
+    op: "set" | "unset" | "merge";
+    path: PatchPath;
+    value?: CoreExprNode;
+} | {
+    kind: "effect";
+    type: string;
+    params: Record<string, CoreExprNode>;
+} | {
+    kind: "call";
+    flow: string;
+} | {
+    kind: "halt";
+    reason?: string;
+} | {
+    kind: "fail";
+    code: string;
+    message?: CoreExprNode;
+};
+type CompilerFlowNode = {
+    kind: "seq";
+    steps: CompilerFlowNode[];
+} | {
+    kind: "if";
+    cond: CompilerExprNode;
+    then: CompilerFlowNode;
+    else?: CompilerFlowNode;
+} | {
+    kind: "patch";
+    op: "set" | "unset" | "merge";
+    path: PatchPath;
+    value?: CompilerExprNode;
+} | {
+    kind: "effect";
+    type: string;
+    params: Record<string, CompilerExprNode>;
+} | {
+    kind: "call";
+    flow: string;
+} | {
+    kind: "halt";
+    reason?: string;
+} | {
+    kind: "fail";
+    code: string;
+    message?: CompilerExprNode;
+};
+/**
+ * Field type definition
+ */
+type FieldType = "string" | "number" | "boolean" | "null" | "object" | "array" | {
+    enum: readonly unknown[];
+};
+/**
+ * Field specification
+ */
+interface FieldSpec {
+    type: FieldType;
+    required: boolean;
+    default?: unknown;
+    description?: string;
+    fields?: Record<string, FieldSpec>;
+    items?: FieldSpec;
+}
+/**
+ * State specification
+ */
+interface StateSpec {
+    fields: Record<string, FieldSpec>;
+}
+/**
+ * Computed field specification
+ */
+interface ComputedFieldSpec {
+    deps: string[];
+    expr: CoreExprNode;
+    description?: string;
+}
+interface CompilerComputedFieldSpec {
+    deps: string[];
+    expr: CompilerExprNode;
+    description?: string;
+}
+/**
+ * Computed specification
+ */
+interface ComputedSpec {
+    fields: Record<string, ComputedFieldSpec>;
+}
+/**
+ * Action specification
+ */
+interface ActionSpec {
+    flow: CoreFlowNode;
+    input?: FieldSpec;
+    available?: CoreExprNode;
+    description?: string;
+}
+interface CompilerActionSpec {
+    flow: CompilerFlowNode;
+    input?: FieldSpec;
+    available?: CompilerExprNode;
+    description?: string;
+}
+/**
+ * Domain schema (output IR)
+ */
+/**
+ * v0.3.3: Type specification (named type declaration)
+ */
+interface TypeSpec {
+    name: string;
+    definition: TypeDefinition;
+}
+/**
+ * v0.3.3: Type definition structure
+ */
+type TypeDefinition = {
+    kind: "primitive";
+    type: string;
+} | {
+    kind: "array";
+    element: TypeDefinition;
+} | {
+    kind: "record";
+    key: TypeDefinition;
+    value: TypeDefinition;
+} | {
+    kind: "object";
+    fields: Record<string, {
+        type: TypeDefinition;
+        optional: boolean;
+    }>;
+} | {
+    kind: "union";
+    types: TypeDefinition[];
+} | {
+    kind: "literal";
+    value: string | number | boolean | null;
+} | {
+    kind: "ref";
+    name: string;
+};
+interface DomainSchema {
+    id: string;
+    version: string;
+    hash: string;
+    /** v0.3.3: Named type declarations */
+    types: Record<string, TypeSpec>;
+    state: StateSpec;
+    computed: ComputedSpec;
+    actions: Record<string, ActionSpec>;
+    meta?: {
+        name?: string;
+        description?: string;
+        authors?: string[];
+    };
+}
+interface CanonicalDomainSchema {
+    id: string;
+    version: string;
+    hash: string;
+    types: Record<string, TypeSpec>;
+    state: StateSpec;
+    computed: {
+        fields: Record<string, CompilerComputedFieldSpec>;
+    };
+    actions: Record<string, CompilerActionSpec>;
+    meta?: {
+        name?: string;
+        description?: string;
+        authors?: string[];
+    };
+}
+interface GenerateResult {
+    schema: DomainSchema | null;
+    diagnostics: Diagnostic[];
+}
+interface GenerateCanonicalResult {
+    schema: CanonicalDomainSchema | null;
+    diagnostics: Diagnostic[];
+}
+declare function generateCanonical(program: ProgramNode): GenerateCanonicalResult;
+/**
+ * Generate runtime-ready DomainSchema from MEL AST.
+ */
+declare function generate(program: ProgramNode): GenerateResult;
+
+/**
+ * Expression Normalizer
+ * Converts MEL operators and function calls to Core ExprNode format
+ * Based on MEL SPEC v0.3.1 Section 4 and FDR-MEL-038
+ */
+
+/**
+ * Normalize a binary operator to Core ExprNode
+ */
+declare function normalizeExpr(op: BinaryOperator, left: CoreExprNode, right: CoreExprNode): CoreExprNode;
+/**
+ * Function name to Core ExprNode mapping
+ */
+declare function normalizeFunctionCall(name: string, args: CoreExprNode[]): CoreExprNode;
+
+/**
+ * System Value Lowering
+ * Transforms $system.* references into effect-based acquisition
+ * Based on MEL SPEC v0.3.1 Section 5.4
+ */
+
+/**
+ * Apply system value lowering to a domain schema
+ */
+declare function lowerSystemValues(schema: DomainSchema): DomainSchema;
+
+/**
+ * TypeExpr to MEL Renderer
+ *
+ * Converts TypeExpr AST to MEL type syntax.
+ *
+ * @example
+ * // { kind: "primitive", name: "string" } -> "string"
+ * // { kind: "array", element: { kind: "ref", name: "Todo" } } -> "Array<Todo>"
+ * // { kind: "union", members: [...] } -> "string | number | null"
+ */
+/**
+ * TypeExpr type from translator package
+ */
+type TypeExpr = {
+    kind: "primitive";
+    name: "string" | "number" | "boolean" | "null";
+} | {
+    kind: "literal";
+    value: string | number | boolean | null;
+} | {
+    kind: "ref";
+    name: string;
+} | {
+    kind: "array";
+    element: TypeExpr;
+} | {
+    kind: "record";
+    key: TypeExpr;
+    value: TypeExpr;
+} | {
+    kind: "union";
+    members: TypeExpr[];
+} | {
+    kind: "object";
+    fields: TypeField[];
+};
+type TypeField = {
+    readonly name: string;
+    readonly optional: boolean;
+    readonly type: TypeExpr;
+};
+/**
+ * Renders a TypeExpr to MEL type syntax string.
+ *
+ * @param typeExpr - The TypeExpr to render
+ * @returns MEL type syntax string
+ */
+declare function renderTypeExpr(typeExpr: TypeExpr): string;
+/**
+ * Renders a TypeField with optional default value.
+ *
+ * @param field - The TypeField to render
+ * @param defaultValue - Optional default value
+ * @returns MEL field declaration string
+ */
+declare function renderTypeField(field: TypeField, defaultValue?: unknown): string;
+/**
+ * Renders a JavaScript value to MEL syntax.
+ */
+declare function renderValue(value: unknown): string;
+
+/**
+ * ExprNode to MEL Renderer
+ *
+ * Converts ExprNode AST to MEL expression syntax.
+ *
+ * @example
+ * // { kind: "lit", value: 5 } -> "5"
+ * // { kind: "get", path: "count" } -> "count"
+ * // { kind: "add", left: { kind: "get", path: "x" }, right: { kind: "lit", value: 1 } } -> "add(x, 1)"
+ * // { kind: "gt", left: { kind: "get", path: "count" }, right: { kind: "lit", value: 0 } } -> "gt(count, 0)"
+ */
+/**
+ * ExprNode type (subset from core package)
+ */
+type ExprNode = {
+    kind: "lit";
+    value: unknown;
+} | {
+    kind: "get";
+    path: string;
+} | {
+    kind: "eq";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "neq";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "gt";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "gte";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "lt";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "lte";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "and";
+    args: ExprNode[];
+} | {
+    kind: "or";
+    args: ExprNode[];
+} | {
+    kind: "not";
+    arg: ExprNode;
+} | {
+    kind: "if";
+    cond: ExprNode;
+    then: ExprNode;
+    else: ExprNode;
+} | {
+    kind: "add";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "sub";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "mul";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "div";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "mod";
+    left: ExprNode;
+    right: ExprNode;
+} | {
+    kind: "concat";
+    args: ExprNode[];
+} | {
+    kind: "substring";
+    str: ExprNode;
+    start: ExprNode;
+    end?: ExprNode;
+} | {
+    kind: "trim";
+    str: ExprNode;
+} | {
+    kind: "len";
+    arg: ExprNode;
+} | {
+    kind: "at";
+    array: ExprNode;
+    index: ExprNode;
+} | {
+    kind: "first";
+    array: ExprNode;
+} | {
+    kind: "last";
+    array: ExprNode;
+} | {
+    kind: "slice";
+    array: ExprNode;
+    start: ExprNode;
+    end?: ExprNode;
+} | {
+    kind: "includes";
+    array: ExprNode;
+    item: ExprNode;
+} | {
+    kind: "filter";
+    array: ExprNode;
+    predicate: ExprNode;
+} | {
+    kind: "map";
+    array: ExprNode;
+    mapper: ExprNode;
+} | {
+    kind: "find";
+    array: ExprNode;
+    predicate: ExprNode;
+} | {
+    kind: "every";
+    array: ExprNode;
+    predicate: ExprNode;
+} | {
+    kind: "some";
+    array: ExprNode;
+    predicate: ExprNode;
+} | {
+    kind: "append";
+    array: ExprNode;
+    items: ExprNode[];
+} | {
+    kind: "object";
+    fields: Record<string, ExprNode>;
+} | {
+    kind: "field";
+    object: ExprNode;
+    property: string;
+} | {
+    kind: "keys";
+    obj: ExprNode;
+} | {
+    kind: "values";
+    obj: ExprNode;
+} | {
+    kind: "entries";
+    obj: ExprNode;
+} | {
+    kind: "merge";
+    objects: ExprNode[];
+} | {
+    kind: "typeof";
+    arg: ExprNode;
+} | {
+    kind: "isNull";
+    arg: ExprNode;
+} | {
+    kind: "coalesce";
+    args: ExprNode[];
+};
+/**
+ * Renders an ExprNode to MEL expression syntax string.
+ *
+ * @param expr - The ExprNode to render
+ * @returns MEL expression syntax string
+ */
+declare function renderExprNode(expr: ExprNode): string;
+
+/**
+ * PatchOp to MEL Renderer
+ *
+ * Converts PatchOp AST to MEL syntax snippets.
+ *
+ * Note: These are fragments, not complete domain definitions.
+ * The caller is responsible for assembling fragments into a valid MEL domain.
+ */
+
+type AddTypeOp = {
+    kind: "addType";
+    typeName: string;
+    typeExpr: TypeExpr;
+};
+type AddFieldOp = {
+    kind: "addField";
+    typeName: string;
+    field: TypeField & {
+        defaultValue?: unknown;
+    };
+};
+type SetFieldTypeOp = {
+    kind: "setFieldType";
+    path: string;
+    typeExpr: TypeExpr;
+};
+type SetDefaultValueOp = {
+    kind: "setDefaultValue";
+    path: string;
+    value: unknown;
+};
+type AddConstraintOp = {
+    kind: "addConstraint";
+    targetPath: string;
+    rule: ExprNode;
+    message?: string;
+};
+type AddComputedOp = {
+    kind: "addComputed";
+    name: string;
+    expr: ExprNode;
+    deps?: string[];
+};
+type AddActionAvailableOp = {
+    kind: "addActionAvailable";
+    actionName: string;
+    expr: ExprNode;
+};
+type PatchOp = AddTypeOp | AddFieldOp | SetFieldTypeOp | SetDefaultValueOp | AddConstraintOp | AddComputedOp | AddActionAvailableOp;
+interface RenderOptions {
+    /**
+     * Indentation string (default: "  ")
+     */
+    indent?: string;
+    /**
+     * Include comments with metadata
+     */
+    includeComments?: boolean;
+    /**
+     * Comment prefix for metadata
+     */
+    commentPrefix?: string;
+}
+/**
+ * Renders a PatchOp to MEL syntax string.
+ *
+ * @param op - The PatchOp to render
+ * @param options - Rendering options
+ * @returns MEL syntax string
+ */
+declare function renderPatchOp(op: PatchOp, options?: RenderOptions): string;
+/**
+ * Gets the type name from a semantic path.
+ *
+ * @example
+ * // "Todo.title" -> "Todo"
+ * // "User.address.city" -> "User"
+ * // "count" -> undefined
+ */
+declare function extractTypeName(path: string): string | undefined;
+
+/**
+ * PatchFragment to MEL Renderer
+ *
+ * Converts PatchFragment to MEL syntax with metadata comments.
+ */
+
+interface PatchFragment {
+    /**
+     * Unique fragment identifier (content-addressed)
+     */
+    fragmentId: string;
+    /**
+     * Source intent identifier
+     */
+    sourceIntentId: string;
+    /**
+     * Fragment operation
+     */
+    op: PatchOp;
+    /**
+     * Confidence score (0-1)
+     */
+    confidence: number;
+    /**
+     * Evidence strings
+     */
+    evidence: string[];
+    /**
+     * Creation timestamp (ISO 8601)
+     */
+    createdAt: string;
+}
+interface FragmentRenderOptions extends RenderOptions {
+    /**
+     * Include fragment metadata as comments
+     */
+    includeMetadata?: boolean;
+    /**
+     * Include evidence as comments
+     */
+    includeEvidence?: boolean;
+    /**
+     * Include confidence score
+     */
+    includeConfidence?: boolean;
+    /**
+     * Include fragment ID
+     */
+    includeFragmentId?: boolean;
+}
+/**
+ * Renders a PatchFragment to MEL syntax string with optional metadata.
+ *
+ * @param fragment - The PatchFragment to render
+ * @param options - Rendering options
+ * @returns MEL syntax string with metadata comments
+ */
+declare function renderFragment(fragment: PatchFragment, options?: FragmentRenderOptions): string;
+/**
+ * Renders multiple PatchFragments to MEL syntax string.
+ *
+ * @param fragments - The PatchFragments to render
+ * @param options - Rendering options
+ * @returns MEL syntax string with all fragments
+ */
+declare function renderFragments(fragments: PatchFragment[], options?: FragmentRenderOptions): string;
+/**
+ * Renders PatchFragments grouped by operation kind.
+ *
+ * @param fragments - The PatchFragments to render
+ * @param options - Rendering options
+ * @returns Object with rendered strings grouped by operation kind
+ */
+declare function renderFragmentsByKind(fragments: PatchFragment[], options?: FragmentRenderOptions): Record<string, string>;
+/**
+ * Renders PatchFragments as a complete MEL domain block.
+ *
+ * @param domainName - The domain name
+ * @param fragments - The PatchFragments to render
+ * @param options - Rendering options
+ * @returns Complete MEL domain string
+ */
+declare function renderAsDomain(domainName: string, fragments: PatchFragment[], options?: FragmentRenderOptions): string;
+
+/**
+ * Lowering Error Types
+ *
+ * Defines error types for MEL IR → Core IR lowering.
+ *
+ * @see SPEC v0.4.0 §17.6
+ */
+/**
+ * Lowering error codes.
+ *
+ * @see SPEC v0.4.0 §17.6
+ */
+type LoweringErrorCode = 
+/** var in non-effect context, sys in schema */
+"INVALID_KIND_FOR_CONTEXT"
+/** Unknown function name in call node */
+ | "UNKNOWN_CALL_FN"
+/** sys.system in Translator path */
+ | "INVALID_SYS_PATH"
+/** get.base is not var(item) */
+ | "UNSUPPORTED_BASE"
+/** Malformed node structure */
+ | "INVALID_SHAPE"
+/** Unknown node kind */
+ | "UNKNOWN_NODE_KIND";
+/**
+ * Lowering error class.
+ *
+ * Thrown when MEL IR cannot be lowered to Core IR.
+ *
+ * @see SPEC v0.4.0 §17.6
+ */
+declare class LoweringError extends Error {
+    readonly code: LoweringErrorCode;
+    readonly path?: string[];
+    readonly details?: Record<string, unknown>;
+    constructor(code: LoweringErrorCode, message: string, options?: {
+        path?: string[];
+        details?: Record<string, unknown>;
+    });
+}
+/**
+ * Create a lowering error for invalid kind in context.
+ *
+ * @example
+ * throw invalidKindForContext("var", "schema");
+ */
+declare function invalidKindForContext(kind: string, context: string, path?: string[]): LoweringError;
+/**
+ * Create a lowering error for unknown call function.
+ *
+ * @example
+ * throw unknownCallFn("unknownFunc");
+ */
+declare function unknownCallFn(fn: string, path?: string[]): LoweringError;
+/**
+ * Create a lowering error for invalid sys path.
+ *
+ * @example
+ * throw invalidSysPath(["system", "uuid"]);
+ */
+declare function invalidSysPath(sysPath: string[], path?: string[]): LoweringError;
+/**
+ * Create a lowering error for unsupported base expression.
+ *
+ * @example
+ * throw unsupportedBase("call");
+ */
+declare function unsupportedBase(baseKind: string, path?: string[]): LoweringError;
+/**
+ * Create a lowering error for invalid shape.
+ *
+ * @example
+ * throw invalidShape("missing 'value' field");
+ */
+declare function invalidShape(description: string, path?: string[]): LoweringError;
+/**
+ * Create a lowering error for unknown node kind.
+ *
+ * @example
+ * throw unknownNodeKind("foo");
+ */
+declare function unknownNodeKind(kind: string, path?: string[]): LoweringError;
+
+/**
+ * Patch Lowering
+ *
+ * Transforms PatchFragment[] (MEL IR) to ConditionalPatchOp[] (Core IR).
+ *
+ * @see SPEC v0.4.0 §17.4, §17.5
+ */
+
+/**
+ * MEL TypeExpr (Translator output).
+ */
+type MelTypeExpr = {
+    kind: "primitive";
+    name: "string" | "number" | "boolean" | "null";
+} | {
+    kind: "array";
+    element: MelTypeExpr;
+} | {
+    kind: "object";
+    fields: MelTypeField[];
+} | {
+    kind: "union";
+    members: MelTypeExpr[];
+} | {
+    kind: "literal";
+    value: string | number | boolean | null;
+} | {
+    kind: "ref";
+    name: string;
+};
+/**
+ * MEL TypeField.
+ */
+type MelTypeField = {
+    name: string;
+    type: MelTypeExpr;
+    optional?: boolean;
+};
+/**
+ * MEL PatchOp (Translator output - schema operations).
+ *
+ * @see SPEC v0.4.0 §17.4
+ */
+type MelPatchOp = {
+    kind: "addType";
+    typeName: string;
+    typeExpr: MelTypeExpr;
+} | {
+    kind: "addField";
+    typeName: string;
+    field: MelTypeField & {
+        defaultValue?: unknown;
+    };
+} | {
+    kind: "setFieldType";
+    path: string;
+    typeExpr: MelTypeExpr;
+} | {
+    kind: "setDefaultValue";
+    path: string;
+    value: unknown;
+} | {
+    kind: "addConstraint";
+    targetPath: string;
+    rule: MelExprNode;
+    message?: string;
+} | {
+    kind: "addComputed";
+    name: string;
+    expr: MelExprNode;
+    deps?: string[];
+} | {
+    kind: "addActionAvailable";
+    actionName: string;
+    expr: MelExprNode;
+};
+/**
+ * MEL PatchFragment (Translator output).
+ *
+ * Contains MEL IR expressions that need lowering.
+ *
+ * @see SPEC v0.4.0 §17.4
+ */
+interface MelPatchFragment {
+    /**
+     * Unique fragment identifier (content-addressed).
+     */
+    fragmentId: string;
+    /**
+     * Source intent identifier.
+     */
+    sourceIntentId: string;
+    /**
+     * Fragment operation with MEL IR expressions.
+     */
+    op: MelPatchOp;
+    /**
+     * Optional condition (MEL IR).
+     * Preserved in output as Core IR.
+     */
+    condition?: MelExprNode;
+    /**
+     * Confidence score (0-1).
+     */
+    confidence: number;
+    /**
+     * Evidence strings.
+     */
+    evidence: string[];
+    /**
+     * Creation timestamp (ISO 8601).
+     */
+    createdAt: string;
+}
+/**
+ * Lowered TypeExpr (Core format).
+ */
+type LoweredTypeExpr = {
+    kind: "primitive";
+    name: "string" | "number" | "boolean" | "null";
+} | {
+    kind: "array";
+    element: LoweredTypeExpr;
+} | {
+    kind: "object";
+    fields: LoweredTypeField[];
+} | {
+    kind: "union";
+    members: LoweredTypeExpr[];
+} | {
+    kind: "literal";
+    value: string | number | boolean | null;
+} | {
+    kind: "ref";
+    name: string;
+};
+/**
+ * Lowered TypeField.
+ */
+type LoweredTypeField = {
+    name: string;
+    type: LoweredTypeExpr;
+    optional?: boolean;
+};
+/**
+ * Lowered PatchOp (Core IR expressions).
+ *
+ * Same structure as MelPatchOp but with Core IR expressions.
+ */
+type LoweredPatchOp = {
+    kind: "addType";
+    typeName: string;
+    typeExpr: LoweredTypeExpr;
+} | {
+    kind: "addField";
+    typeName: string;
+    field: LoweredTypeField & {
+        defaultValue?: unknown;
+    };
+} | {
+    kind: "setFieldType";
+    path: string;
+    typeExpr: LoweredTypeExpr;
+} | {
+    kind: "setDefaultValue";
+    path: string;
+    value: unknown;
+} | {
+    kind: "addConstraint";
+    targetPath: string;
+    rule: ExprNode$2;
+    message?: string;
+} | {
+    kind: "addComputed";
+    name: string;
+    expr: ExprNode$2;
+    deps?: string[];
+} | {
+    kind: "addActionAvailable";
+    actionName: string;
+    expr: ExprNode$2;
+};
+/**
+ * Schema conditional patch operation (intermediate IR for Translator → Host).
+ *
+ * Used for schema evolution operations (addType, addField, addComputed, etc.).
+ * Preserves fragment condition for later evaluation.
+ *
+ * @see SPEC v0.4.0 §17.5
+ */
+interface SchemaConditionalPatchOp {
+    /**
+     * Fragment identifier (for tracing).
+     */
+    fragmentId: string;
+    /**
+     * Condition expression (Core IR).
+     * If present, op is only applied when condition evaluates to true.
+     *
+     * @see FDR-MEL-073
+     */
+    condition?: ExprNode$2;
+    /**
+     * Lowered patch operation.
+     */
+    op: LoweredPatchOp;
+    /**
+     * Confidence (preserved from fragment).
+     */
+    confidence: number;
+}
+/**
+ * @deprecated Use SchemaConditionalPatchOp instead.
+ */
+type ConditionalPatchOp = SchemaConditionalPatchOp;
+/**
+ * Lower PatchFragment[] to SchemaConditionalPatchOp[].
+ *
+ * Transforms MEL IR expressions to Core IR expressions.
+ * Preserves fragment conditions for evaluation phase.
+ *
+ * @param fragments - MEL IR patch fragments from Translator
+ * @param ctx - Patch lowering context
+ * @returns Core IR schema conditional patch operations
+ *
+ * @see SPEC v0.4.0 §17.5
+ */
+declare function lowerPatchFragments(fragments: MelPatchFragment[], ctx: PatchLoweringContext): SchemaConditionalPatchOp[];
+
+/**
+ * Runtime Patch Lowering
+ *
+ * Transforms MEL runtime patches (set/unset/merge) to Core IR.
+ *
+ * @see SPEC v0.4.0 §17.5
+ */
+
+/**
+ * MEL runtime patch operation type.
+ *
+ * @see SPEC v0.4.0 §17.5
+ */
+type MelRuntimePatchOp = "set" | "unset" | "merge";
+/**
+ * MEL path segment for runtime patches before expression lowering.
+ */
+type MelIRPathSegment = {
+    kind: "prop";
+    name: string;
+} | {
+    kind: "expr";
+    expr: MelExprNode;
+};
+/**
+ * MEL runtime patch path represented as IR segments.
+ */
+type MelIRPatchPath = MelIRPathSegment[];
+/**
+ * Lowered runtime IR path segment.
+ */
+type IRPathSegment = {
+    kind: "prop";
+    name: string;
+} | {
+    kind: "expr";
+    expr: ExprNode$2;
+};
+/**
+ * Runtime patch path represented as IR segments.
+ */
+type IRPatchPath = IRPathSegment[];
+/**
+ * MEL runtime patch (Translator output for action patches).
+ *
+ * Contains MEL IR expressions that need lowering to Core IR.
+ */
+interface MelRuntimePatch {
+    /**
+     * Optional condition (MEL IR).
+     * If present, patch is only applied when condition evaluates to true.
+     */
+    condition?: MelExprNode;
+    /**
+     * Patch operation type.
+     */
+    op: MelRuntimePatchOp;
+    /**
+     * Target path in snapshot.
+     * Uses IR segments and is resolved to concrete PatchPath at evaluation time.
+     */
+    path: MelIRPatchPath;
+    /**
+     * Value expression (MEL IR) for set/merge operations.
+     * Required for "set" and "merge", forbidden for "unset".
+     */
+    value?: MelExprNode;
+}
+/**
+ * Runtime ConditionalPatchOp for snapshot state mutations.
+ *
+ * This is the intermediate representation between Translator output
+ * and final concrete Patch[]. Host must call evaluateRuntimePatches()
+ * to get concrete values.
+ *
+ * @see SPEC v0.4.0 §17.5, §20
+ */
+interface RuntimeConditionalPatchOp {
+    /**
+     * Optional condition expression (Core IR).
+     * If present, patch is only applied when condition evaluates to true.
+     *
+     * @see SPEC v0.4.0 §18.6 (boolean-only conditions)
+     */
+    condition?: ExprNode$2;
+    /**
+     * Patch operation type.
+     */
+    op: "set" | "unset" | "merge";
+    /**
+     * Target path in IR form.
+     * Evaluator resolves this to concrete PatchPath.
+     */
+    path: IRPatchPath;
+    /**
+     * Value expression (Core IR) for set/merge operations.
+     * Required for "set" and "merge", undefined for "unset".
+     */
+    value?: ExprNode$2;
+}
+/**
+ * Lower MEL runtime patches to Core IR.
+ *
+ * Transforms MEL IR expressions to Core IR expressions.
+ * The returned patches still contain expressions that need to be
+ * evaluated by evaluateRuntimePatches() to get concrete values.
+ *
+ * @param patches - MEL IR runtime patches from Translator
+ * @param ctx - Expression lowering context
+ * @returns Core IR runtime conditional patches
+ *
+ * @see SPEC v0.4.0 §17.5
+ */
+declare function lowerRuntimePatches(patches: MelRuntimePatch[], ctx: ExprLoweringContext): RuntimeConditionalPatchOp[];
+/**
+ * Lower a single MEL runtime patch to Core IR.
+ */
+declare function lowerRuntimePatch(patch: MelRuntimePatch, ctx: ExprLoweringContext): RuntimeConditionalPatchOp;
+
+/**
+ * Evaluation Context Types
+ *
+ * Defines context for expression evaluation.
+ *
+ * @see SPEC v0.4.0 §18.3
+ */
+/**
+ * Minimal snapshot shape for evaluation.
+ *
+ * @see SPEC v0.4.0 §18.7
+ */
+interface EvaluationSnapshot {
+    /**
+     * Domain data (matches StateSpec).
+     * Path resolution default target.
+     */
+    data: unknown;
+    /**
+     * Computed values (matches ComputedSpec).
+     * Accessed via bare key paths (e.g., "total", not "computed.total").
+     */
+    computed: Record<string, unknown>;
+}
+/**
+ * Intent metadata for evaluation.
+ *
+ * @see SPEC v0.4.0 §18.3
+ */
+interface EvaluationMeta {
+    /**
+     * Intent identifier.
+     */
+    intentId: string;
+    /**
+     * Actor reference (optional).
+     */
+    actor?: {
+        type: string;
+        id: string;
+    };
+    /**
+     * Timestamp (optional).
+     */
+    timestamp?: number;
+}
+/**
+ * Evaluation context.
+ *
+ * @see SPEC v0.4.0 §18.3
+ */
+interface EvaluationContext {
+    /**
+     * Current snapshot for state lookups.
+     * Paths resolve to snapshot.data.* by default.
+     */
+    snapshot: EvaluationSnapshot;
+    /**
+     * Intent metadata.
+     * Paths starting with "meta.*" resolve here.
+     */
+    meta: EvaluationMeta;
+    /**
+     * Intent input.
+     * Paths starting with "input.*" resolve here.
+     */
+    input: Record<string, unknown>;
+    /**
+     * Current $item value (for effect.args evaluation).
+     * Paths starting with "$item.*" resolve here.
+     */
+    item?: unknown;
+}
+/**
+ * Create a minimal evaluation context.
+ *
+ * @param options - Context options
+ * @returns Evaluation context
+ */
+declare function createEvaluationContext(options: Partial<EvaluationContext> & {
+    meta: EvaluationMeta;
+}): EvaluationContext;
+/**
+ * Create a working snapshot by cloning and applying a patch.
+ *
+ * Used for sequential evaluation semantics.
+ *
+ * @see FDR-MEL-070
+ */
+declare function applyPatchToWorkingSnapshot(snapshot: EvaluationSnapshot, path: string, value: unknown): EvaluationSnapshot;
+
+/**
+ * Expression Evaluation
+ *
+ * Evaluates Core IR expressions against evaluation context.
+ *
+ * AXIOM A35: Expression evaluation is total; invalid operations return null, never throw.
+ *
+ * @see SPEC v0.4.0 §18
+ */
+
+/**
+ * Evaluate a Core IR expression.
+ *
+ * Total function: returns null on any error, never throws.
+ *
+ * @param expr - Core IR expression
+ * @param ctx - Evaluation context
+ * @returns Evaluated value or null on error
+ *
+ * @see SPEC v0.4.0 §18.4, A35
+ */
+declare function evaluateExpr(expr: ExprNode$2, ctx: EvaluationContext): unknown;
+
+/**
+ * Patch Evaluation
+ *
+ * Evaluates ConditionalPatchOp[] to produce concrete schema operations.
+ *
+ * @see SPEC v0.4.0 §18.5, §18.6
+ */
+
+/**
+ * Evaluated schema patch operation.
+ *
+ * All conditions have been evaluated and values resolved where appropriate.
+ * Expressions in addComputed, addConstraint, addActionAvailable are preserved
+ * for runtime evaluation by Core.
+ */
+type EvaluatedPatchOp = LoweredPatchOp;
+/**
+ * Result of evaluating a conditional patch.
+ */
+interface EvaluatedPatch {
+    /**
+     * Fragment identifier (for tracing).
+     */
+    fragmentId: string;
+    /**
+     * The evaluated operation.
+     */
+    op: EvaluatedPatchOp;
+    /**
+     * Confidence (preserved from fragment).
+     */
+    confidence: number;
+    /**
+     * Whether condition was evaluated (true) or there was no condition.
+     */
+    conditionEvaluated: boolean;
+}
+/**
+ * Result of patch evaluation.
+ */
+interface PatchEvaluationResult {
+    /**
+     * Patches that passed their conditions.
+     */
+    patches: EvaluatedPatch[];
+    /**
+     * Patches that were skipped due to false/null conditions.
+     */
+    skipped: Array<{
+        fragmentId: string;
+        reason: "false" | "null" | "non-boolean";
+    }>;
+    /**
+     * Final working snapshot after all evaluations.
+     */
+    finalSnapshot: EvaluationSnapshot;
+}
+/**
+ * Evaluate conditional patch operations.
+ *
+ * Implements sequential evaluation semantics: later patches see effects
+ * of earlier patches via working snapshot.
+ *
+ * Conditions are boolean-only: true applies, false/null/non-boolean skips.
+ *
+ * @param ops - Conditional patch operations from lowering phase
+ * @param ctx - Initial evaluation context
+ * @returns Evaluation result with applied and skipped patches
+ *
+ * @see SPEC v0.4.0 §18.5, FDR-MEL-070, FDR-MEL-073
+ */
+declare function evaluateConditionalPatchOps(ops: ConditionalPatchOp[], ctx: EvaluationContext): PatchEvaluationResult;
+/**
+ * Simple evaluation: returns patches that pass conditions.
+ *
+ * Does not track skipped patches or maintain sequential semantics.
+ * Use this for stateless condition evaluation.
+ *
+ * @param ops - Conditional patch operations
+ * @param ctx - Evaluation context
+ * @returns Patches that passed their conditions
+ */
+declare function evaluatePatches(ops: ConditionalPatchOp[], ctx: EvaluationContext): EvaluatedPatch[];
+/**
+ * Evaluate expressions in a patch operation to concrete values.
+ *
+ * Use this when you need fully concrete values (no expressions).
+ *
+ * Note: addComputed.expr, addConstraint.rule, and addActionAvailable.expr
+ * are meant to remain as expressions for runtime evaluation by Core.
+ *
+ * @param op - Lowered patch operation
+ * @param ctx - Evaluation context
+ * @returns Patch operation with evaluated expressions
+ */
+declare function evaluatePatchExpressions(op: LoweredPatchOp, ctx: EvaluationContext): LoweredPatchOp;
+/**
+ * Check if a condition evaluates to true.
+ *
+ * Boolean-only: only true returns true.
+ * false, null, and non-boolean values return false.
+ *
+ * @param condition - Condition expression (or undefined for always-true)
+ * @param ctx - Evaluation context
+ * @returns True if condition passes
+ *
+ * @see FDR-MEL-073
+ */
+declare function evaluateCondition(condition: ExprNode$2 | undefined, ctx: EvaluationContext): boolean;
+/**
+ * Classify a condition evaluation result.
+ *
+ * @param condition - Condition expression
+ * @param ctx - Evaluation context
+ * @returns Classification of condition result
+ */
+declare function classifyCondition(condition: ExprNode$2 | undefined, ctx: EvaluationContext): {
+    passes: boolean;
+    reason: "no-condition" | "true" | "false" | "null" | "non-boolean";
+};
+
+/**
+ * Runtime Patch Evaluation
+ *
+ * Evaluates RuntimeConditionalPatchOp[] to produce concrete Patch[].
+ */
+
+/**
+ * Skip reason for runtime patches.
+ */
+type RuntimePatchSkipReason = "false" | "null" | "non-boolean" | "invalid-path";
+/**
+ * Skipped patch info.
+ */
+interface SkippedRuntimePatch {
+    /**
+     * Index in the original ops array.
+     */
+    index: number;
+    /**
+     * Target path (display form).
+     */
+    path: string;
+    /**
+     * Reason why patch was skipped.
+     */
+    reason: RuntimePatchSkipReason;
+}
+/**
+ * Result of runtime patch evaluation with trace information.
+ */
+interface RuntimePatchEvaluationResult {
+    /**
+     * Concrete patches that passed conditions.
+     * Order is preserved from input.
+     */
+    patches: Patch[];
+    /**
+     * Patches that were skipped due to false/null/non-boolean conditions.
+     */
+    skipped: SkippedRuntimePatch[];
+    /**
+     * Non-fatal warnings collected during evaluation.
+     */
+    warnings: string[];
+    /**
+     * Final working snapshot after all evaluations.
+     */
+    finalSnapshot: EvaluationSnapshot;
+}
+/**
+ * Evaluate runtime conditional patches to concrete Patch[].
+ */
+declare function evaluateRuntimePatches(ops: RuntimeConditionalPatchOp[], ctx: EvaluationContext): Patch[];
+/**
+ * Evaluate runtime patches with trace information.
+ */
+declare function evaluateRuntimePatchesWithTrace(ops: RuntimeConditionalPatchOp[], ctx: EvaluationContext): RuntimePatchEvaluationResult;
+
+/**
+ * MEL Text Ingest API
+ *
+ * Compiles MEL text to DomainSchema or RuntimeConditionalPatchOp[].
+ *
+ * @see SPEC v0.4.0 §19
+ */
+
+/**
+ * Trace entry for compilation steps.
+ */
+interface CompileTrace {
+    phase: "lex" | "parse" | "analyze" | "generate" | "lower";
+    durationMs: number;
+    details?: Record<string, unknown>;
+}
+/**
+ * Domain compilation options.
+ */
+interface CompileMelDomainOptions {
+    mode: "domain";
+    fnTableVersion?: string;
+}
+/**
+ * Domain compilation result.
+ *
+ * @see SPEC v0.4.0 §19.1
+ */
+interface CompileMelDomainResult {
+    /**
+     * Compiled schema, or null if errors occurred.
+     */
+    schema: DomainSchema | null;
+    /**
+     * Compilation trace.
+     */
+    trace: CompileTrace[];
+    /**
+     * Warning diagnostics.
+     */
+    warnings: Diagnostic[];
+    /**
+     * Error diagnostics.
+     */
+    errors: Diagnostic[];
+}
+/**
+ * Patch compilation options.
+ */
+interface CompileMelPatchOptions {
+    mode: "patch";
+    /**
+     * Action name for context.
+     */
+    actionName: string;
+    /**
+     * Allowed system path prefixes.
+     * Default: ["meta", "input"] (system is forbidden per §20.3).
+     */
+    allowSysPaths?: {
+        prefixes: ("meta" | "input")[];
+    };
+    /**
+     * Function table version.
+     */
+    fnTableVersion?: string;
+}
+/**
+ * Patch compilation result.
+ *
+ * @see SPEC v0.4.0 §19.2
+ */
+interface CompileMelPatchResult {
+    /**
+     * Compiled patch operations.
+     * These still contain Core IR expressions that need evaluation.
+     */
+    ops: RuntimeConditionalPatchOp[];
+    /**
+     * Compilation trace.
+     */
+    trace: CompileTrace[];
+    /**
+     * Warning diagnostics.
+     */
+    warnings: Diagnostic[];
+    /**
+     * Error diagnostics.
+     */
+    errors: Diagnostic[];
+}
+/**
+ * Compile MEL text to DomainSchema.
+ *
+ * Takes a complete MEL domain definition and produces a DomainSchema
+ * suitable for use with core.compute().
+ *
+ * @param melText - MEL domain source text
+ * @param options - Compilation options
+ * @returns Compilation result with schema or errors
+ *
+ * @see SPEC v0.4.0 §19.1
+ */
+declare function compileMelDomain(melText: string, options?: CompileMelDomainOptions): CompileMelDomainResult;
+/**
+ * Compile MEL patch text to RuntimeConditionalPatchOp[].
+ *
+ * Takes MEL patch statements (set, unset, merge) and produces
+ * RuntimeConditionalPatchOp[] with Core IR expressions.
+ *
+ * The returned ops still contain expressions that need to be evaluated
+ * by evaluateRuntimePatches() to get concrete values.
+ *
+ * Constraints:
+ * - §20.3: $system.* is forbidden in Translator path
+ *
+ * @param melText - MEL patch source text
+ * @param options - Compilation options
+ * @returns Compilation result with ops or errors
+ *
+ * @see SPEC v0.4.0 §19.2
+ */
+declare function compileMelPatch(melText: string, options: CompileMelPatchOptions): CompileMelPatchResult;
+
 /**
  * @manifesto-ai/compiler
  *
  * MEL (Manifesto Expression Language) compiler.
  * Provides lexer, parser, analyzer, lowering, evaluation, and rendering.
  */
-export * from "./lexer/index.js";
-export * from "./parser/index.js";
-export * from "./analyzer/index.js";
-export * from "./diagnostics/index.js";
-export * from "./generator/index.js";
-export { renderTypeExpr, renderTypeField, renderValue, renderExprNode, renderPatchOp, extractTypeName, renderFragment, renderFragments, renderFragmentsByKind, renderAsDomain, type TypeExpr, type TypeField, type ExprNode as RendererExprNode, type PatchOp, type AddTypeOp, type AddFieldOp, type SetFieldTypeOp, type SetDefaultValueOp, type AddConstraintOp, type AddComputedOp, type AddActionAvailableOp, type RenderOptions, type PatchFragment, type FragmentRenderOptions, } from "./renderer/index.js";
-export * from "./lowering/index.js";
-export * from "./evaluation/index.js";
-export * from "./api/index.js";
-export type { DomainSchema as DomainModule } from "./generator/ir.js";
-//# sourceMappingURL=index.d.ts.map
+
+interface CompileOptions {
+    /** Whether to lower system values during compilation */
+    lowerSystemValues?: boolean;
+    /** Skip scope/semantic validation */
+    skipSemanticAnalysis?: boolean;
+    /** Backward-compatible passthrough for legacy callers */
+    mode?: "domain";
+}
+interface CompileResult {
+    schema: DomainSchema | null;
+    trace: CompileTrace[];
+    warnings: Diagnostic[];
+    errors: Diagnostic[];
+    success: boolean;
+}
+/**
+ * Backward-compatible compile API.
+ *
+ * Current public API is `compileMelDomain`, but several test/code paths and CLI
+ * still call this legacy helper.
+ *
+ * This wrapper keeps the legacy contract:
+ * - returns `{ success }`
+ * - supports optional `lowerSystemValues` and `skipSemanticAnalysis`
+ * - includes parse/analyze/generate diagnostics in one result
+ */
+declare function compile(source: string, options?: CompileOptions): CompileResult;
+/**
+ * Backward-compatible token+parse helper.
+ */
+declare function parseSource(source: string): ParseResult;
+/**
+ * Backward-compatible check helper.
+ */
+declare function check(source: string): Diagnostic[];
+
+export { type ASTNode, type ActionNode, type ActionSpec, type AddActionAvailableOp, type AddComputedOp, type AddConstraintOp, type AddFieldOp, type AddTypeOp, type AllowedSysPrefix, type ArrayLiteralExprNode, type ArrayTypeNode, type BinaryExprNode, type BinaryOperator, type CanonicalDomainSchema, type CompileMelDomainOptions, type CompileMelDomainResult, type CompileMelPatchOptions, type CompileMelPatchResult, type CompileOptions, type CompileResult, type CompileTrace, type CompilerActionSpec, type CompilerComputedFieldSpec, type CompilerExprNode, type CompilerFlowNode, type ComputedFieldSpec, type ComputedNode, type ComputedSpec, type ConditionalPatchOp, type CoreExprNode, type CoreFlowNode, DEFAULT_ACTION_CONTEXT, DEFAULT_PATCH_CONTEXT, DEFAULT_SCHEMA_CONTEXT, DIAGNOSTIC_CODES, type Diagnostic, type DiagnosticCode, type DiagnosticSeverity, type DomainMember, type DomainSchema as DomainModule, type DomainNode, type DomainSchema, EFFECT_ARGS_CONTEXT, type EffectArgNode, type EffectStmtNode, type EvaluatedPatch, type EvaluatedPatchOp, type EvaluationContext, type EvaluationMeta, type EvaluationSnapshot, type ExprLoweringContext, type ExprNode$1 as ExprNode, type FailStmtNode, type FieldSpec, type FieldType, type FlowDeclNode, type FlowStmtNode, type FragmentRenderOptions, type FunctionCallExprNode, type GenerateCanonicalResult, type GenerateResult, type GuardedStmtNode, type IRPatchPath, type IRPathSegment, type IdentifierExprNode, type ImportNode, type IncludeStmtNode, type IndexAccessExprNode, type IndexSegmentNode, type InnerStmtNode, type IterationVarExprNode, KEYWORDS, type LexResult, Lexer, type LiteralExprNode, type LiteralTypeNode, type LoweredPatchOp, type LoweredTypeExpr, type LoweredTypeField, LoweringError, type LoweringErrorCode, type MelExprNode, type MelIRPatchPath, type MelIRPathSegment, type MelObjField, type MelPatchFragment, type MelPatchOp, type MelPathNode, type MelPathSegment, type MelPrimitive, type MelRuntimePatch, type MelRuntimePatchOp, type MelSystemPath, type MelTypeExpr, type MelTypeField, type ObjectLiteralExprNode, type ObjectPropertyNode, type ObjectTypeNode, type OnceIntentStmtNode, type OnceStmtNode, type ParamNode, type ParseResult, Parser, type PatchEvaluationResult, type PatchFragment, type PatchLoweringContext, type PatchOp, type PatchStmtNode, type PathNode, type PathSegmentNode, type Position, Precedence, type ProgramNode, type PropertyAccessExprNode, type PropertySegmentNode, RESERVED_KEYWORDS, type RecordTypeNode, type RelatedDiagnostic, type RenderOptions, type ExprNode as RendererExprNode, type RuntimeConditionalPatchOp, type RuntimePatchEvaluationResult, type RuntimePatchSkipReason, type SchemaConditionalPatchOp, Scope, type ScopeAnalysisResult, ScopeAnalyzer, SemanticValidator, type SetDefaultValueOp, type SetFieldTypeOp, type SimpleTypeNode, type SkippedRuntimePatch, type SourceLocation, type StateFieldNode, type StateNode, type StateSpec, type StopStmtNode, type Symbol, type SymbolKind, type SystemIdentExprNode, type TernaryExprNode, type Token, type TokenKind, type TypeDeclNode, type TypeDefinition, type TypeExpr, type TypeExprNode, type TypeField, type TypeFieldNode, type TypeSpec, type UnaryExprNode, type UnionTypeNode, type ValidationResult, type WhenStmtNode, analyzeScope, applyPatchToWorkingSnapshot, check, classifyCondition, compile, compileMelDomain, compileMelPatch, createError, createEvaluationContext, createInfo, createLocation, createPointLocation, createPosition, createToken, createWarning, evaluateCondition, evaluateConditionalPatchOps, evaluateExpr, evaluatePatchExpressions, evaluatePatches, evaluateRuntimePatches, evaluateRuntimePatchesWithTrace, extractTypeName, filterBySeverity, formatDiagnostic, formatDiagnosticCode, formatDiagnostics, generate, generateCanonical, getBinaryPrecedence, getDiagnosticInfo, getKeywordKind, hasErrors, invalidKindForContext, invalidShape, invalidSysPath, isBinaryOp, isError, isExprNode, isKeyword, isReserved, isRightAssociative, isStmtNode, isUnaryOp, lowerExprNode, lowerPatchFragments, lowerRuntimePatch, lowerRuntimePatches, lowerSystemValues, mergeLocations, normalizeExpr, normalizeFunctionCall, parse, parseSource, renderAsDomain, renderExprNode, renderFragment, renderFragments, renderFragmentsByKind, renderPatchOp, renderTypeExpr, renderTypeField, renderValue, tokenToBinaryOp, tokenize, unknownCallFn, unknownNodeKind, unsupportedBase, validateSemantics };