@manifesto-ai/compiler 1.8.3 → 1.9.1

package/dist/{chunk-AYZTDA3J.js → chunk-LI5HNMZV.js}

@@ -1,6 +1,6 @@
 import {
   compileMelDomain
-} from "./chunk-4JJQCFJH.js";
+} from "./chunk-7TT6Y5ZC.js";
 
 // src/mel-module.ts
 function formatDiagnostic(diagnostic) {
@@ -30,4 +30,4 @@ export {
   formatDiagnostic,
   compileMelToModuleCode
 };
-//# sourceMappingURL=chunk-AYZTDA3J.js.map
+//# sourceMappingURL=chunk-LI5HNMZV.js.map

package/dist/{chunk-K4IKHGOP.js → chunk-WZRGVNJK.js}

@@ -1,9 +1,9 @@
 import {
   formatDiagnostic
-} from "./chunk-AYZTDA3J.js";
+} from "./chunk-LI5HNMZV.js";
 import {
   compileMelDomain
-} from "./chunk-4JJQCFJH.js";
+} from "./chunk-7TT6Y5ZC.js";
 
 // src/unplugin.ts
 import { createUnplugin } from "unplugin";
@@ -71,4 +71,4 @@ ${details}`);
 export {
   unpluginMel
 };
-//# sourceMappingURL=chunk-K4IKHGOP.js.map
+//# sourceMappingURL=chunk-WZRGVNJK.js.map

package/dist/diagnostics/codes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * MEL Compiler Diagnostic Codes
+ * Based on MEL SPEC v0.3.3 Appendix A
+ */
+/**
+ * Diagnostic code information
+ */
+export interface DiagnosticCode {
+    code: string;
+    message: string;
+    category: "syntax" | "semantic" | "type" | "system";
+}
+/**
+ * All diagnostic codes
+ */
+export declare const DIAGNOSTIC_CODES: Record<string, DiagnosticCode>;
+/**
+ * Get diagnostic code information
+ */
+export declare function getDiagnosticInfo(code: string): DiagnosticCode | undefined;
+/**
+ * Format a diagnostic code for display
+ */
+export declare function formatDiagnosticCode(code: string): string;

package/dist/diagnostics/format.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Plain-text Diagnostic Formatter
+ *
+ * Browser-safe (no ANSI colors). Produces human-readable error messages
+ * with optional source context and caret indicators.
+ *
+ * @module
+ */
+import type { Diagnostic } from "./types.js";
+/**
+ * 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 }
+ *                ^^^
+ * ```
+ */
+export declare function formatDiagnostic(diagnostic: Diagnostic, source?: string): string;
+/**
+ * Format multiple diagnostics, separated by blank lines.
+ */
+export declare function formatDiagnostics(diagnostics: Diagnostic[], source?: string): string;

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Diagnostics Module - Error and warning reporting
+ */
+export * from "./types.js";
+export * from "./codes.js";
+export { formatDiagnostic, formatDiagnostics } from "./format.js";

package/dist/diagnostics/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Diagnostic Types for MEL Compiler
+ * Error and warning reporting structures
+ */
+import type { SourceLocation } from "../lexer/source-location.js";
+/**
+ * Severity level of a diagnostic
+ */
+export type DiagnosticSeverity = "error" | "warning" | "info";
+/**
+ * A diagnostic message (error, warning, or info)
+ */
+export 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)
+ */
+export interface RelatedDiagnostic {
+    message: string;
+    location: SourceLocation;
+}
+/**
+ * Create an error diagnostic
+ */
+export declare function createError(code: string, message: string, location: SourceLocation, options?: {
+    source?: string;
+    suggestion?: string;
+    related?: RelatedDiagnostic[];
+}): Diagnostic;
+/**
+ * Create a warning diagnostic
+ */
+export declare function createWarning(code: string, message: string, location: SourceLocation, options?: {
+    source?: string;
+    suggestion?: string;
+}): Diagnostic;
+/**
+ * Create an info diagnostic
+ */
+export declare function createInfo(code: string, message: string, location: SourceLocation): Diagnostic;
+/**
+ * Check if a diagnostic is an error
+ */
+export declare function isError(diagnostic: Diagnostic): boolean;
+/**
+ * Check if any diagnostics contain errors
+ */
+export declare function hasErrors(diagnostics: Diagnostic[]): boolean;
+/**
+ * Filter diagnostics by severity
+ */
+export declare function filterBySeverity(diagnostics: Diagnostic[], severity: DiagnosticSeverity): Diagnostic[];

package/dist/esbuild.d.ts

@@ -1,8 +1,6 @@
-import * as unplugin from 'unplugin';
-import { M as MelPluginOptions } from './unplugin-6wnvFiEo.js';
-export { a as MelCodegenOptions } from './unplugin-6wnvFiEo.js';
-import '@manifesto-ai/codegen';
-
-declare const melPlugin: (options: MelPluginOptions) => unplugin.EsbuildPlugin;
-
-export { MelPluginOptions, melPlugin as default, melPlugin };
+/**
+ * esbuild plugin for MEL files.
+ */
+export type { MelPluginOptions, MelCodegenOptions } from "./unplugin.js";
+export declare const melPlugin: (options: import("./unplugin.js").MelPluginOptions) => import("unplugin").EsbuildPlugin;
+export default melPlugin;

package/dist/esbuild.js

@@ -1,8 +1,8 @@
 import {
   unpluginMel
-} from "./chunk-K4IKHGOP.js";
-import "./chunk-AYZTDA3J.js";
-import "./chunk-4JJQCFJH.js";
+} from "./chunk-WZRGVNJK.js";
+import "./chunk-LI5HNMZV.js";
+import "./chunk-7TT6Y5ZC.js";
 
 // src/esbuild.ts
 var melPlugin = unpluginMel.esbuild;

package/dist/evaluation/context.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export declare function applyPatchToWorkingSnapshot(snapshot: EvaluationSnapshot, path: string, value: unknown): EvaluationSnapshot;

package/dist/evaluation/evaluate-expr.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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
+ */
+import type { ExprNode } from "@manifesto-ai/core";
+import type { EvaluationContext } from "./context.js";
+/**
+ * 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
+ */
+export declare function evaluateExpr(expr: ExprNode, ctx: EvaluationContext): unknown;

package/dist/evaluation/evaluate-patch.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Patch Evaluation
+ *
+ * Evaluates ConditionalPatchOp[] to produce concrete schema operations.
+ *
+ * @see SPEC v0.4.0 §18.5, §18.6
+ */
+import type { ExprNode as CoreExprNode } from "@manifesto-ai/core";
+import type { ConditionalPatchOp, LoweredPatchOp } from "../lowering/lower-patch.js";
+import type { EvaluationContext, EvaluationSnapshot } from "./context.js";
+/**
+ * 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.
+ */
+export type EvaluatedPatchOp = LoweredPatchOp;
+/**
+ * Result of evaluating a conditional patch.
+ */
+export 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.
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export declare function evaluateCondition(condition: CoreExprNode | undefined, ctx: EvaluationContext): boolean;
+/**
+ * Classify a condition evaluation result.
+ *
+ * @param condition - Condition expression
+ * @param ctx - Evaluation context
+ * @returns Classification of condition result
+ */
+export declare function classifyCondition(condition: CoreExprNode | undefined, ctx: EvaluationContext): {
+    passes: boolean;
+    reason: "no-condition" | "true" | "false" | "null" | "non-boolean";
+};

package/dist/evaluation/evaluate-runtime-patch.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Runtime Patch Evaluation
+ *
+ * Evaluates RuntimeConditionalPatchOp[] to produce concrete Patch[].
+ */
+import type { Patch } from "@manifesto-ai/core";
+import type { RuntimeConditionalPatchOp } from "../lowering/lower-runtime-patch.js";
+import type { EvaluationContext, EvaluationSnapshot } from "./context.js";
+/**
+ * Skip reason for runtime patches.
+ */
+export type RuntimePatchSkipReason = "false" | "null" | "non-boolean" | "invalid-path";
+/**
+ * Skipped patch info.
+ */
+export 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.
+ */
+export 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[].
+ */
+export declare function evaluateRuntimePatches(ops: RuntimeConditionalPatchOp[], ctx: EvaluationContext): Patch[];
+/**
+ * Evaluate runtime patches with trace information.
+ */
+export declare function evaluateRuntimePatchesWithTrace(ops: RuntimeConditionalPatchOp[], ctx: EvaluationContext): RuntimePatchEvaluationResult;

package/dist/evaluation/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Evaluation Module
+ *
+ * Evaluates Core IR expressions and conditional patches.
+ *
+ * @see SPEC v0.4.0 §18
+ */
+export type { EvaluationSnapshot, EvaluationMeta, EvaluationContext, } from "./context.js";
+export { createEvaluationContext, applyPatchToWorkingSnapshot, } from "./context.js";
+export { evaluateExpr } from "./evaluate-expr.js";
+export type { EvaluatedPatchOp, EvaluatedPatch, PatchEvaluationResult, } from "./evaluate-patch.js";
+export { evaluateConditionalPatchOps, evaluatePatches, evaluatePatchExpressions, evaluateCondition, classifyCondition, } from "./evaluate-patch.js";
+export type { RuntimePatchSkipReason, SkippedRuntimePatch, RuntimePatchEvaluationResult, } from "./evaluate-runtime-patch.js";
+export { evaluateRuntimePatches, evaluateRuntimePatchesWithTrace, } from "./evaluate-runtime-patch.js";

package/dist/generator/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generator Module - Transforms MEL AST to Core IR
+ */
+export * from "./ir.js";
+export * from "./normalizer.js";
+export * from "./lowering.js";

package/dist/generator/ir.d.ts

@@ -0,0 +1,185 @@
+/**
+ * IR Generator - Transforms MEL AST to Core DomainSchema
+ * Based on MEL SPEC v0.3.3 Section 5
+ */
+import type { Diagnostic } from "../diagnostics/types.js";
+import type { ProgramNode } from "../parser/ast.js";
+import type { MelExprNode } from "../lowering/lower-expr.js";
+import { type ExprNode as RuntimeExprNode, type FlowNode as RuntimeFlowNode, type PatchPath } from "@manifesto-ai/core";
+/**
+ * Core ExprNode types (simplified, matching core/schema/expr.ts)
+ */
+export type CoreExprNode = RuntimeExprNode;
+export type CompilerExprNode = MelExprNode;
+/**
+ * Core FlowNode types (matching core/schema/flow.ts)
+ */
+export type CoreFlowNode = RuntimeFlowNode;
+export 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
+ */
+export type FieldType = "string" | "number" | "boolean" | "null" | "object" | "array" | {
+    enum: readonly unknown[];
+};
+/**
+ * Field specification
+ */
+export interface FieldSpec {
+    type: FieldType;
+    required: boolean;
+    default?: unknown;
+    description?: string;
+    fields?: Record<string, FieldSpec>;
+    items?: FieldSpec;
+}
+/**
+ * State specification
+ */
+export interface StateSpec {
+    fields: Record<string, FieldSpec>;
+}
+/**
+ * Computed field specification
+ */
+export interface ComputedFieldSpec {
+    deps: string[];
+    expr: CoreExprNode;
+    description?: string;
+}
+export interface CompilerComputedFieldSpec {
+    deps: string[];
+    expr: CompilerExprNode;
+    description?: string;
+}
+/**
+ * Computed specification
+ */
+export interface ComputedSpec {
+    fields: Record<string, ComputedFieldSpec>;
+}
+/**
+ * Action specification
+ */
+export interface ActionSpec {
+    flow: CoreFlowNode;
+    input?: FieldSpec;
+    available?: CoreExprNode;
+    description?: string;
+}
+export interface CompilerActionSpec {
+    flow: CompilerFlowNode;
+    input?: FieldSpec;
+    available?: CompilerExprNode;
+    description?: string;
+}
+/**
+ * Domain schema (output IR)
+ */
+/**
+ * v0.3.3: Type specification (named type declaration)
+ */
+export interface TypeSpec {
+    name: string;
+    definition: TypeDefinition;
+}
+/**
+ * v0.3.3: Type definition structure
+ */
+export 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;
+};
+export 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[];
+    };
+}
+export 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[];
+    };
+}
+export interface GenerateResult {
+    schema: DomainSchema | null;
+    diagnostics: Diagnostic[];
+}
+export interface GenerateCanonicalResult {
+    schema: CanonicalDomainSchema | null;
+    diagnostics: Diagnostic[];
+}
+export declare function generateCanonical(program: ProgramNode): GenerateCanonicalResult;
+/**
+ * Generate runtime-ready DomainSchema from MEL AST.
+ */
+export declare function generate(program: ProgramNode): GenerateResult;