@manifesto-ai/compiler 1.9.0 → 3.0.0

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;

package/dist/generator/lowering.d.ts

@@ -0,0 +1,10 @@
+/**
+ * System Value Lowering
+ * Transforms $system.* references into effect-based acquisition
+ * Based on MEL SPEC v0.3.1 Section 5.4
+ */
+import type { DomainSchema } from "./ir.js";
+/**
+ * Apply system value lowering to a domain schema
+ */
+export declare function lowerSystemValues(schema: DomainSchema): DomainSchema;

package/dist/generator/normalizer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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
+ */
+import type { CoreExprNode } from "./ir.js";
+import type { BinaryOperator } from "../parser/ast.js";
+/**
+ * Normalize a binary operator to Core ExprNode
+ */
+export declare function normalizeExpr(op: BinaryOperator, left: CoreExprNode, right: CoreExprNode): CoreExprNode;
+/**
+ * Function name to Core ExprNode mapping
+ */
+export declare function normalizeFunctionCall(name: string, args: CoreExprNode[]): CoreExprNode;

package/dist/generator/runtime-lowering.d.ts

@@ -0,0 +1,2 @@
+import type { CanonicalDomainSchema, DomainSchema } from "./ir.js";
+export declare function lowerCanonicalSchema(schema: CanonicalDomainSchema): DomainSchema;