@manifesto-ai/compiler 1.9.0 → 3.0.0

package/dist/index.js

@@ -53,7 +53,7 @@ import {
   unsupportedBase,
   validateAndExpandFlows,
   validateSemantics
-} from "./chunk-4JJQCFJH.js";
+} from "./chunk-7TT6Y5ZC.js";
 
 // src/diagnostics/codes.ts
 var DIAGNOSTIC_CODES = {

package/dist/lexer/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Lexer Module - Tokenizes MEL source code
+ */
+export * from "./tokens.js";
+export * from "./source-location.js";
+export * from "./lexer.js";

package/dist/lexer/lexer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * MEL Lexer
+ * Tokenizes MEL source code based on SPEC v0.3.1 Section 3
+ */
+import type { Diagnostic } from "../diagnostics/types.js";
+import { type Token } from "./tokens.js";
+/**
+ * Result of lexical analysis
+ */
+export interface LexResult {
+    tokens: Token[];
+    diagnostics: Diagnostic[];
+}
+/**
+ * Lexer for MEL source code
+ */
+export 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
+ */
+export declare function tokenize(source: string, sourcePath?: string): LexResult;

package/dist/lexer/source-location.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Source Location Types
+ * Tracks positions in MEL source code for error reporting
+ */
+/**
+ * A position in source code (1-based line/column)
+ */
+export 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)
+ */
+export interface SourceLocation {
+    start: Position;
+    end: Position;
+    /** Optional source file path */
+    source?: string;
+}
+/**
+ * Create a position
+ */
+export declare function createPosition(line: number, column: number, offset: number): Position;
+/**
+ * Create a source location from two positions
+ */
+export declare function createLocation(start: Position, end: Position, source?: string): SourceLocation;
+/**
+ * Create a zero-width location at a position
+ */
+export declare function createPointLocation(pos: Position, source?: string): SourceLocation;
+/**
+ * Merge two locations into one spanning both
+ */
+export declare function mergeLocations(a: SourceLocation, b: SourceLocation): SourceLocation;

package/dist/lexer/tokens.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Token Types for MEL Lexer
+ * Based on MEL SPEC v0.3.3 Section 3
+ */
+import type { SourceLocation } from "./source-location.js";
+/**
+ * All token kinds in MEL
+ */
+export 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
+ */
+export 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
+ */
+export declare const KEYWORDS: Record<string, TokenKind>;
+/**
+ * Reserved keywords (JS keywords that are forbidden in MEL)
+ */
+export declare const RESERVED_KEYWORDS: Set<string>;
+/**
+ * Check if a token is a keyword
+ */
+export declare function isKeyword(lexeme: string): boolean;
+/**
+ * Check if a token is a reserved word
+ */
+export 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")
+ */
+export declare function getKeywordKind(lexeme: string): TokenKind | undefined;
+/**
+ * Create a token
+ */
+export declare function createToken(kind: TokenKind, lexeme: string, location: SourceLocation, value?: unknown): Token;

package/dist/lowering/context.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 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
+ */
+export type AllowedSysPrefix = "meta" | "input";
+/**
+ * Context for single expression lowering.
+ *
+ * @see SPEC v0.4.0 §17.2
+ */
+export 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
+ */
+export 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.
+ */
+export declare const DEFAULT_SCHEMA_CONTEXT: ExprLoweringContext;
+/**
+ * Default expression lowering context for action mode.
+ */
+export declare const DEFAULT_ACTION_CONTEXT: ExprLoweringContext;
+/**
+ * Context for effect.args (allows $item).
+ */
+export declare const EFFECT_ARGS_CONTEXT: ExprLoweringContext;
+/**
+ * Default patch lowering context.
+ */
+export declare const DEFAULT_PATCH_CONTEXT: PatchLoweringContext;

package/dist/lowering/errors.d.ts

@@ -0,0 +1,83 @@
+/**
+ * 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
+ */
+export 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
+ */
+export 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");
+ */
+export declare function invalidKindForContext(kind: string, context: string, path?: string[]): LoweringError;
+/**
+ * Create a lowering error for unknown call function.
+ *
+ * @example
+ * throw unknownCallFn("unknownFunc");
+ */
+export declare function unknownCallFn(fn: string, path?: string[]): LoweringError;
+/**
+ * Create a lowering error for invalid sys path.
+ *
+ * @example
+ * throw invalidSysPath(["system", "uuid"]);
+ */
+export declare function invalidSysPath(sysPath: string[], path?: string[]): LoweringError;
+/**
+ * Create a lowering error for unsupported base expression.
+ *
+ * @example
+ * throw unsupportedBase("call");
+ */
+export declare function unsupportedBase(baseKind: string, path?: string[]): LoweringError;
+/**
+ * Create a lowering error for invalid shape.
+ *
+ * @example
+ * throw invalidShape("missing 'value' field");
+ */
+export declare function invalidShape(description: string, path?: string[]): LoweringError;
+/**
+ * Create a lowering error for unknown node kind.
+ *
+ * @example
+ * throw unknownNodeKind("foo");
+ */
+export declare function unknownNodeKind(kind: string, path?: string[]): LoweringError;

package/dist/lowering/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Lowering Module
+ *
+ * Transforms MEL IR to Core IR.
+ *
+ * @see SPEC v0.4.0 §17
+ */
+export type { AllowedSysPrefix, ExprLoweringContext, PatchLoweringContext, } from "./context.js";
+export { DEFAULT_SCHEMA_CONTEXT, DEFAULT_ACTION_CONTEXT, EFFECT_ARGS_CONTEXT, DEFAULT_PATCH_CONTEXT, } from "./context.js";
+export type { LoweringErrorCode } from "./errors.js";
+export { LoweringError, invalidKindForContext, unknownCallFn, invalidSysPath, unsupportedBase, invalidShape, unknownNodeKind, } from "./errors.js";
+export type { MelPrimitive, MelPathSegment, MelPathNode, MelSystemPath, MelObjField, MelExprNode, } from "./lower-expr.js";
+export { lowerExprNode } from "./lower-expr.js";
+export type { MelTypeExpr, MelTypeField, MelPatchOp, MelPatchFragment, LoweredTypeExpr, LoweredTypeField, LoweredPatchOp, SchemaConditionalPatchOp, 
+/** @deprecated Use SchemaConditionalPatchOp */
+ConditionalPatchOp, } from "./lower-patch.js";
+export { lowerPatchFragments } from "./lower-patch.js";
+export type { MelRuntimePatchOp, MelIRPathSegment, MelIRPatchPath, MelRuntimePatch, IRPathSegment, IRPatchPath, RuntimeConditionalPatchOp, } from "./lower-runtime-patch.js";
+export { lowerRuntimePatches, lowerRuntimePatch } from "./lower-runtime-patch.js";

package/dist/lowering/lower-expr.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Expression Lowering
+ *
+ * Transforms MEL Canonical IR (8 kinds) to Core Runtime IR (30+ kinds).
+ *
+ * @see SPEC v0.4.0 §17
+ */
+import type { ExprNode as CoreExprNode } from "@manifesto-ai/core";
+import type { ExprLoweringContext } from "./context.js";
+/**
+ * MEL primitive value.
+ */
+export type MelPrimitive = null | boolean | number | string;
+/**
+ * MEL path segment.
+ */
+export type MelPathSegment = {
+    kind: "prop";
+    name: string;
+};
+/**
+ * MEL path node array.
+ */
+export type MelPathNode = MelPathSegment[];
+/**
+ * MEL system path as segment array.
+ */
+export type MelSystemPath = string[];
+/**
+ * MEL object field.
+ */
+export type MelObjField = {
+    key: string;
+    value: MelExprNode;
+};
+/**
+ * MEL Canonical IR (8 kinds).
+ *
+ * @see SPEC v0.4.0 §17.1.1
+ */
+export 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
+ */
+export declare function lowerExprNode(input: MelExprNode, ctx: ExprLoweringContext): CoreExprNode;

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

@@ -0,0 +1,230 @@
+/**
+ * Patch Lowering
+ *
+ * Transforms PatchFragment[] (MEL IR) to ConditionalPatchOp[] (Core IR).
+ *
+ * @see SPEC v0.4.0 §17.4, §17.5
+ */
+import type { ExprNode as CoreExprNode } from "@manifesto-ai/core";
+import type { PatchLoweringContext } from "./context.js";
+import { MelExprNode } from "./lower-expr.js";
+/**
+ * MEL TypeExpr (Translator output).
+ */
+export 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.
+ */
+export type MelTypeField = {
+    name: string;
+    type: MelTypeExpr;
+    optional?: boolean;
+};
+/**
+ * MEL PatchOp (Translator output - schema operations).
+ *
+ * @see SPEC v0.4.0 §17.4
+ */
+export 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
+ */
+export 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).
+ */
+export 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.
+ */
+export type LoweredTypeField = {
+    name: string;
+    type: LoweredTypeExpr;
+    optional?: boolean;
+};
+/**
+ * Lowered PatchOp (Core IR expressions).
+ *
+ * Same structure as MelPatchOp but with Core IR expressions.
+ */
+export 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: CoreExprNode;
+    message?: string;
+} | {
+    kind: "addComputed";
+    name: string;
+    expr: CoreExprNode;
+    deps?: string[];
+} | {
+    kind: "addActionAvailable";
+    actionName: string;
+    expr: CoreExprNode;
+};
+/**
+ * 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
+ */
+export 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?: CoreExprNode;
+    /**
+     * Lowered patch operation.
+     */
+    op: LoweredPatchOp;
+    /**
+     * Confidence (preserved from fragment).
+     */
+    confidence: number;
+}
+/**
+ * @deprecated Use SchemaConditionalPatchOp instead.
+ */
+export 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
+ */
+export declare function lowerPatchFragments(fragments: MelPatchFragment[], ctx: PatchLoweringContext): SchemaConditionalPatchOp[];