@manifesto-ai/compiler 1.8.3 → 1.9.1

package/dist/lowering/lower-runtime-patch.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Runtime Patch Lowering
+ *
+ * Transforms MEL runtime patches (set/unset/merge) to Core IR.
+ *
+ * @see SPEC v0.4.0 §17.5
+ */
+import type { ExprNode as CoreExprNode } from "@manifesto-ai/core";
+import type { ExprLoweringContext } from "./context.js";
+import type { MelExprNode } from "./lower-expr.js";
+/**
+ * MEL runtime patch operation type.
+ *
+ * @see SPEC v0.4.0 §17.5
+ */
+export type MelRuntimePatchOp = "set" | "unset" | "merge";
+/**
+ * MEL path segment for runtime patches before expression lowering.
+ */
+export type MelIRPathSegment = {
+    kind: "prop";
+    name: string;
+} | {
+    kind: "expr";
+    expr: MelExprNode;
+};
+/**
+ * MEL runtime patch path represented as IR segments.
+ */
+export type MelIRPatchPath = MelIRPathSegment[];
+/**
+ * Lowered runtime IR path segment.
+ */
+export type IRPathSegment = {
+    kind: "prop";
+    name: string;
+} | {
+    kind: "expr";
+    expr: CoreExprNode;
+};
+/**
+ * Runtime patch path represented as IR segments.
+ */
+export type IRPatchPath = IRPathSegment[];
+/**
+ * MEL runtime patch (Translator output for action patches).
+ *
+ * Contains MEL IR expressions that need lowering to Core IR.
+ */
+export 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
+ */
+export 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?: CoreExprNode;
+    /**
+     * 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?: CoreExprNode;
+}
+/**
+ * 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
+ */
+export 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;
+/**
+ * Lower a single MEL runtime patch to Core IR.
+ *
+ * Exported for cases where individual patch lowering is needed.
+ */
+export { lowerRuntimePatch };

package/dist/lowering/to-mel-expr.d.ts

@@ -0,0 +1,12 @@
+import type { ExprNode } from "../parser/ast.js";
+import type { MelExprNode, MelPathNode } from "./lower-expr.js";
+export interface ToMelExprOptions {
+    resolveIdentifier?: (name: string) => MelExprNode;
+    resolveSystemIdent?: (path: string[]) => MelExprNode;
+}
+export declare function toMelExpr(input: ExprNode, options?: ToMelExprOptions): MelExprNode;
+export declare function getPathExpr(...segments: string[]): MelExprNode;
+export declare function getBasePathExpr(base: MelExprNode, ...segments: string[]): MelExprNode;
+export declare function sysPathExpr(...segments: string[]): MelExprNode;
+export declare function objExpr(fields: Record<string, MelExprNode>): MelExprNode;
+export declare function toMelPath(...segments: string[]): MelPathNode;

package/dist/mel-module.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MEL Module Helpers
+ *
+ * Utilities for turning MEL source into JavaScript module code.
+ */
+import type { Diagnostic } from "./diagnostics/types.js";
+export declare function formatDiagnostic(diagnostic: Diagnostic): string;
+/**
+ * Compile MEL source and emit ESM source that exports the compiled schema.
+ *
+ * @param melSource - MEL domain source text
+ * @param sourceId - Human-readable source identifier for diagnostics
+ */
+export declare function compileMelToModuleCode(melSource: string, sourceId: string): string;

package/dist/node-loader.d.ts

@@ -1,18 +1,14 @@
-import { ResolveHook, LoadHook } from 'node:module';
-
 /**
  * Node ESM Loader Hooks for MEL files.
  *
  * Usage: node --loader @manifesto-ai/compiler/node-loader app.ts
  */
-
+import type { LoadHook, ResolveHook } from "node:module";
 /**
  * Node loader resolve hook.
  */
-declare const resolve: ResolveHook;
+export declare const resolve: ResolveHook;
 /**
  * Node loader load hook.
  */
-declare const load: LoadHook;
-
-export { load, resolve };
+export declare const load: LoadHook;

package/dist/node-loader.js

@@ -1,7 +1,7 @@
 import {
   compileMelToModuleCode
-} from "./chunk-AYZTDA3J.js";
-import "./chunk-4JJQCFJH.js";
+} from "./chunk-LI5HNMZV.js";
+import "./chunk-7TT6Y5ZC.js";
 
 // src/node-loader.ts
 import { readFile } from "fs/promises";

package/dist/parser/ast.d.ts

@@ -0,0 +1,367 @@
+/**
+ * AST Node Types for MEL Parser
+ * Based on MEL SPEC v0.3.3 Section 4
+ */
+import type { SourceLocation } from "../lexer/source-location.js";
+/**
+ * Base interface for all AST nodes
+ */
+export interface ASTNode {
+    location: SourceLocation;
+}
+/**
+ * Root node of a MEL program
+ */
+export interface ProgramNode extends ASTNode {
+    kind: "program";
+    imports: ImportNode[];
+    domain: DomainNode;
+}
+/**
+ * Import declaration
+ */
+export interface ImportNode extends ASTNode {
+    kind: "import";
+    names: string[];
+    from: string;
+}
+/**
+ * Domain declaration
+ */
+export interface DomainNode extends ASTNode {
+    kind: "domain";
+    name: string;
+    /** v0.3.3: Named type declarations */
+    types: TypeDeclNode[];
+    members: DomainMember[];
+}
+/**
+ * Domain member types
+ */
+export type DomainMember = StateNode | ComputedNode | ActionNode | FlowDeclNode;
+/**
+ * Type declaration (v0.3.3)
+ * Syntax: type Name = TypeExpr
+ */
+export interface TypeDeclNode extends ASTNode {
+    kind: "typeDecl";
+    name: string;
+    typeExpr: TypeExprNode;
+}
+/**
+ * State block declaration
+ */
+export interface StateNode extends ASTNode {
+    kind: "state";
+    fields: StateFieldNode[];
+}
+/**
+ * State field declaration
+ */
+export interface StateFieldNode extends ASTNode {
+    kind: "stateField";
+    name: string;
+    typeExpr: TypeExprNode;
+    initializer?: ExprNode;
+}
+/**
+ * Computed value declaration
+ */
+export interface ComputedNode extends ASTNode {
+    kind: "computed";
+    name: string;
+    expression: ExprNode;
+}
+/**
+ * Action declaration
+ */
+export interface ActionNode extends ASTNode {
+    kind: "action";
+    name: string;
+    params: ParamNode[];
+    /** v0.3.2: Optional availability condition */
+    available?: ExprNode;
+    body: GuardedStmtNode[];
+}
+/**
+ * Flow declaration (v0.7.0 / ADR-013a)
+ * Raw AST preserves flow declarations until the expansion pass removes them.
+ */
+export interface FlowDeclNode extends ASTNode {
+    kind: "flow";
+    name: string;
+    params: ParamNode[];
+    body: FlowStmtNode[];
+}
+/**
+ * Parameter declaration
+ */
+export interface ParamNode extends ASTNode {
+    kind: "param";
+    name: string;
+    typeExpr: TypeExprNode;
+}
+/**
+ * Guarded statement types (top-level in action body)
+ */
+export 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.
+ */
+export type FlowStmtNode = WhenStmtNode | IncludeStmtNode | OnceStmtNode | OnceIntentStmtNode | PatchStmtNode | EffectStmtNode;
+/**
+ * Inner statement types (inside guards)
+ */
+export type InnerStmtNode = PatchStmtNode | EffectStmtNode | WhenStmtNode | OnceStmtNode | OnceIntentStmtNode | IncludeStmtNode | FailStmtNode | StopStmtNode;
+/**
+ * When guard statement
+ */
+export interface WhenStmtNode extends ASTNode {
+    kind: "when";
+    condition: ExprNode;
+    body: InnerStmtNode[];
+}
+/**
+ * Once guard statement (per-intent idempotency)
+ */
+export interface OnceStmtNode extends ASTNode {
+    kind: "once";
+    marker: PathNode;
+    condition?: ExprNode;
+    body: InnerStmtNode[];
+}
+/**
+ * Once-intent guard statement (per-intent idempotency sugar)
+ */
+export interface OnceIntentStmtNode extends ASTNode {
+    kind: "onceIntent";
+    condition?: ExprNode;
+    body: InnerStmtNode[];
+}
+/**
+ * Include statement (v0.7.0 / ADR-013a)
+ * Raw AST preserves include sites until the expansion pass inlines them.
+ */
+export interface IncludeStmtNode extends ASTNode {
+    kind: "include";
+    flowName: string;
+    args: ExprNode[];
+}
+/**
+ * Patch statement
+ */
+export interface PatchStmtNode extends ASTNode {
+    kind: "patch";
+    path: PathNode;
+    op: "set" | "unset" | "merge";
+    value?: ExprNode;
+}
+/**
+ * Effect statement
+ */
+export interface EffectStmtNode extends ASTNode {
+    kind: "effect";
+    effectType: string;
+    args: EffectArgNode[];
+}
+/**
+ * Effect argument
+ */
+export interface EffectArgNode extends ASTNode {
+    kind: "effectArg";
+    name: string;
+    value: ExprNode | PathNode;
+    isPath: boolean;
+}
+/**
+ * Fail statement (v0.3.2) - terminates flow with error
+ * Compiles to FlowNode { kind: "fail", code, message }
+ */
+export interface FailStmtNode extends ASTNode {
+    kind: "fail";
+    code: string;
+    message?: ExprNode;
+}
+/**
+ * Stop statement (v0.3.2) - early exit, no error
+ * Compiles to FlowNode { kind: "halt", reason }
+ */
+export interface StopStmtNode extends ASTNode {
+    kind: "stop";
+    reason: string;
+}
+/**
+ * Type expression node
+ */
+export type TypeExprNode = SimpleTypeNode | UnionTypeNode | ArrayTypeNode | RecordTypeNode | LiteralTypeNode | ObjectTypeNode;
+export interface SimpleTypeNode extends ASTNode {
+    kind: "simpleType";
+    name: string;
+}
+export interface UnionTypeNode extends ASTNode {
+    kind: "unionType";
+    types: TypeExprNode[];
+}
+export interface ArrayTypeNode extends ASTNode {
+    kind: "arrayType";
+    elementType: TypeExprNode;
+}
+export interface RecordTypeNode extends ASTNode {
+    kind: "recordType";
+    keyType: TypeExprNode;
+    valueType: TypeExprNode;
+}
+export 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)
+ */
+export interface ObjectTypeNode extends ASTNode {
+    kind: "objectType";
+    fields: TypeFieldNode[];
+}
+/**
+ * Type field within an object type
+ */
+export interface TypeFieldNode extends ASTNode {
+    kind: "typeField";
+    name: string;
+    typeExpr: TypeExprNode;
+    optional: boolean;
+}
+/**
+ * All expression types
+ */
+export type ExprNode = LiteralExprNode | IdentifierExprNode | SystemIdentExprNode | IterationVarExprNode | PropertyAccessExprNode | IndexAccessExprNode | FunctionCallExprNode | UnaryExprNode | BinaryExprNode | TernaryExprNode | ObjectLiteralExprNode | ArrayLiteralExprNode;
+/**
+ * Literal expression (number, string, boolean, null)
+ */
+export interface LiteralExprNode extends ASTNode {
+    kind: "literal";
+    value: unknown;
+    literalType: "number" | "string" | "boolean" | "null";
+}
+/**
+ * Identifier expression
+ */
+export interface IdentifierExprNode extends ASTNode {
+    kind: "identifier";
+    name: string;
+}
+/**
+ * System identifier expression ($system.*, $meta.*, $input.*)
+ */
+export interface SystemIdentExprNode extends ASTNode {
+    kind: "systemIdent";
+    path: string[];
+}
+/**
+ * Iteration variable expression ($item only)
+ * v0.3.2: $acc removed - reduce pattern deprecated
+ */
+export interface IterationVarExprNode extends ASTNode {
+    kind: "iterationVar";
+    name: "item";
+}
+/**
+ * Property access expression (a.b)
+ */
+export interface PropertyAccessExprNode extends ASTNode {
+    kind: "propertyAccess";
+    object: ExprNode;
+    property: string;
+}
+/**
+ * Index access expression (a[b])
+ */
+export interface IndexAccessExprNode extends ASTNode {
+    kind: "indexAccess";
+    object: ExprNode;
+    index: ExprNode;
+}
+/**
+ * Function call expression
+ */
+export interface FunctionCallExprNode extends ASTNode {
+    kind: "functionCall";
+    name: string;
+    args: ExprNode[];
+}
+/**
+ * Unary expression (!a, -a)
+ */
+export interface UnaryExprNode extends ASTNode {
+    kind: "unary";
+    operator: "!" | "-";
+    operand: ExprNode;
+}
+/**
+ * Binary operators
+ */
+export type BinaryOperator = "+" | "-" | "*" | "/" | "%" | "==" | "!=" | "<" | "<=" | ">" | ">=" | "&&" | "||" | "??";
+/**
+ * Binary expression (a + b, a && b, etc.)
+ */
+export interface BinaryExprNode extends ASTNode {
+    kind: "binary";
+    operator: BinaryOperator;
+    left: ExprNode;
+    right: ExprNode;
+}
+/**
+ * Ternary expression (a ? b : c)
+ */
+export interface TernaryExprNode extends ASTNode {
+    kind: "ternary";
+    condition: ExprNode;
+    consequent: ExprNode;
+    alternate: ExprNode;
+}
+/**
+ * Object literal expression ({ a: 1, b: 2 })
+ */
+export interface ObjectLiteralExprNode extends ASTNode {
+    kind: "objectLiteral";
+    properties: ObjectPropertyNode[];
+}
+export interface ObjectPropertyNode extends ASTNode {
+    kind: "objectProperty";
+    key: string;
+    value: ExprNode;
+}
+/**
+ * Array literal expression ([1, 2, 3])
+ */
+export interface ArrayLiteralExprNode extends ASTNode {
+    kind: "arrayLiteral";
+    elements: ExprNode[];
+}
+/**
+ * Path node for patch targets and effect destinations
+ */
+export interface PathNode extends ASTNode {
+    kind: "path";
+    segments: PathSegmentNode[];
+}
+export type PathSegmentNode = PropertySegmentNode | IndexSegmentNode;
+export interface PropertySegmentNode extends ASTNode {
+    kind: "propertySegment";
+    name: string;
+}
+export interface IndexSegmentNode extends ASTNode {
+    kind: "indexSegment";
+    index: ExprNode;
+}
+/**
+ * Check if a node is an expression
+ */
+export declare function isExprNode(node: ASTNode): node is ExprNode;
+/**
+ * Check if a node is a statement
+ */
+export declare function isStmtNode(node: ASTNode): node is InnerStmtNode;

package/dist/parser/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parser Module - Parses MEL tokens into AST
+ */
+export * from "./ast.js";
+export * from "./precedence.js";
+export * from "./parser.js";

package/dist/parser/parser.d.ts

@@ -0,0 +1,101 @@
+/**
+ * MEL Parser
+ * Recursive descent parser with Pratt parsing for expressions
+ * Based on MEL SPEC v0.3.3 Section 4
+ */
+import type { Diagnostic } from "../diagnostics/types.js";
+import type { Token } from "../lexer/tokens.js";
+import { type ProgramNode } from "./ast.js";
+/**
+ * Result of parsing
+ */
+export interface ParseResult {
+    program: ProgramNode | null;
+    diagnostics: Diagnostic[];
+}
+/**
+ * Parser for MEL source code
+ */
+export 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
+ */
+export declare function parse(tokens: Token[]): ParseResult;

package/dist/parser/precedence.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Operator Precedence for MEL Parser
+ * Based on MEL SPEC v0.3.1 Section 4.9
+ */
+import type { TokenKind } from "../lexer/tokens.js";
+import type { BinaryOperator } from "./ast.js";
+/**
+ * Precedence levels (higher = binds tighter)
+ */
+export 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
+ */
+export declare function getBinaryPrecedence(kind: TokenKind): Precedence;
+/**
+ * Map token kind to binary operator
+ */
+export declare function tokenToBinaryOp(kind: TokenKind): BinaryOperator | null;
+/**
+ * Check if a token is a binary operator
+ */
+export declare function isBinaryOp(kind: TokenKind): boolean;
+/**
+ * Check if a token is a unary operator
+ */
+export declare function isUnaryOp(kind: TokenKind): boolean;
+/**
+ * Check if operators are right-associative
+ */
+export declare function isRightAssociative(kind: TokenKind): boolean;