@manifesto-ai/compiler 1.7.0 → 1.8.1

package/dist/index.js

@@ -1,4 +1,8 @@
 import {
+  DEFAULT_ACTION_CONTEXT,
+  DEFAULT_PATCH_CONTEXT,
+  DEFAULT_SCHEMA_CONTEXT,
+  EFFECT_ARGS_CONTEXT,
   KEYWORDS,
   Lexer,
   LoweringError,
@@ -9,6 +13,7 @@ import {
   ScopeAnalyzer,
   SemanticValidator,
   analyzeScope,
+  compareUnicodeCodePoints,
   compileMelDomain,
   compileMelPatch,
   createError,
@@ -20,6 +25,7 @@ import {
   createWarning,
   filterBySeverity,
   generate,
+  generateCanonical,
   getBinaryPrecedence,
   getKeywordKind,
   hasErrors,
@@ -35,19 +41,19 @@ import {
   isStmtNode,
   isUnaryOp,
   lowerExprNode,
+  lowerPatchFragments,
   lowerRuntimePatch,
   lowerRuntimePatches,
   mergeLocations,
-  normalizeExpr,
-  normalizeFunctionCall,
   parse,
   tokenToBinaryOp,
   tokenize,
   unknownCallFn,
   unknownNodeKind,
   unsupportedBase,
+  validateAndExpandFlows,
   validateSemantics
-} from "./chunk-QP2LGMBA.js";
+} from "./chunk-4JJQCFJH.js";
 
 // src/diagnostics/codes.ts
 var DIAGNOSTIC_CODES = {
@@ -80,12 +86,12 @@ var DIAGNOSTIC_CODES = {
   },
   E006: {
     code: "E006",
-    message: "fail must be inside a guard (when or once)",
+    message: "fail must be inside a guard (when, once, or onceIntent)",
     category: "semantic"
   },
   E007: {
     code: "E007",
-    message: "stop must be inside a guard (when or once)",
+    message: "stop must be inside a guard (when, once, or onceIntent)",
     category: "semantic"
   },
   E008: {
@@ -108,6 +114,141 @@ var DIAGNOSTIC_CODES = {
     message: "reduce/fold/scan is forbidden - use sum, min, max for aggregation",
     category: "semantic"
   },
+  E013: {
+    code: "E013",
+    message: "Circular include detected",
+    category: "semantic"
+  },
+  E014: {
+    code: "E014",
+    message: "Include expansion depth exceeds limit",
+    category: "semantic"
+  },
+  E015: {
+    code: "E015",
+    message: "Include target is not a declared flow",
+    category: "semantic"
+  },
+  E016: {
+    code: "E016",
+    message: "Include not allowed in InnerStmt position",
+    category: "semantic"
+  },
+  E017: {
+    code: "E017",
+    message: "once() not allowed in flow",
+    category: "semantic"
+  },
+  E018: {
+    code: "E018",
+    message: "onceIntent not allowed in flow",
+    category: "semantic"
+  },
+  E019: {
+    code: "E019",
+    message: "patch not allowed in flow",
+    category: "semantic"
+  },
+  E020: {
+    code: "E020",
+    message: "effect not allowed in flow",
+    category: "semantic"
+  },
+  E021: {
+    code: "E021",
+    message: "Flow parameter name conflicts with top-level identifier",
+    category: "semantic"
+  },
+  E022: {
+    code: "E022",
+    message: "Flow and action share the same name",
+    category: "semantic"
+  },
+  E023: {
+    code: "E023",
+    message: "Wrong number of arguments for included flow",
+    category: "semantic"
+  },
+  E024: {
+    code: "E024",
+    message: "Include argument type mismatch",
+    category: "type"
+  },
+  E030: {
+    code: "E030",
+    message: "Collection element type does not have an 'id' field",
+    category: "type"
+  },
+  E030a: {
+    code: "E030a",
+    message: "Collection element 'id' field is not a primitive type",
+    category: "type"
+  },
+  E030b: {
+    code: "E030b",
+    message: "Duplicate '.id' values detected in state initializer",
+    category: "type"
+  },
+  E031: {
+    code: "E031",
+    message: "updateById/removeById not allowed in this context",
+    category: "semantic"
+  },
+  E032: {
+    code: "E032",
+    message: "Nested transform primitive",
+    category: "semantic"
+  },
+  E033: {
+    code: "E033",
+    message: "Transform primitive collection argument is not a state path",
+    category: "semantic"
+  },
+  E034: {
+    code: "E034",
+    message: "Transform primitive in guard condition",
+    category: "semantic"
+  },
+  E035: {
+    code: "E035",
+    message: "Transform primitive in available condition",
+    category: "semantic"
+  },
+  E040: {
+    code: "E040",
+    message: "Circular computed dependency",
+    category: "semantic"
+  },
+  E041: {
+    code: "E041",
+    message: "Computed references undeclared identifier",
+    category: "semantic"
+  },
+  E042: {
+    code: "E042",
+    message: "State initializer references non-constant value",
+    category: "semantic"
+  },
+  E043: {
+    code: "E043",
+    message: "Non-trivial union type cannot be lowered to FieldSpec",
+    category: "type"
+  },
+  E044: {
+    code: "E044",
+    message: "Recursive named type cannot be lowered to FieldSpec",
+    category: "type"
+  },
+  E045: {
+    code: "E045",
+    message: "Nullable type cannot be lowered to FieldSpec",
+    category: "type"
+  },
+  E046: {
+    code: "E046",
+    message: "Record type cannot be lowered to FieldSpec",
+    category: "type"
+  },
   // ============ Scope Errors (E1xx) ============
   E_UNDEFINED: {
     code: "E_UNDEFINED",
@@ -223,6 +364,182 @@ function formatDiagnostics(diagnostics, source) {
   return diagnostics.map((d) => formatDiagnostic(d, source)).join("\n\n");
 }
 
+// src/generator/normalizer.ts
+function normalizeExpr(op, left, right) {
+  switch (op) {
+    // Arithmetic
+    case "+":
+      return { kind: "add", left, right };
+    case "-":
+      return { kind: "sub", left, right };
+    case "*":
+      return { kind: "mul", left, right };
+    case "/":
+      return { kind: "div", left, right };
+    case "%":
+      return { kind: "mod", left, right };
+    // Comparison
+    case "==":
+      return { kind: "eq", left, right };
+    case "!=":
+      return { kind: "neq", left, right };
+    case "<":
+      return { kind: "lt", left, right };
+    case "<=":
+      return { kind: "lte", left, right };
+    case ">":
+      return { kind: "gt", left, right };
+    case ">=":
+      return { kind: "gte", left, right };
+    // Logical
+    case "&&":
+      return { kind: "and", args: [left, right] };
+    case "||":
+      return { kind: "or", args: [left, right] };
+    // Nullish coalescing
+    case "??":
+      return { kind: "coalesce", args: [left, right] };
+  }
+}
+function normalizeFunctionCall(name, args) {
+  switch (name) {
+    // ============ Arithmetic ============
+    case "add":
+      return { kind: "add", left: args[0], right: args[1] };
+    case "sub":
+      return { kind: "sub", left: args[0], right: args[1] };
+    case "mul":
+      return { kind: "mul", left: args[0], right: args[1] };
+    case "div":
+      return { kind: "div", left: args[0], right: args[1] };
+    case "mod":
+      return { kind: "mod", left: args[0], right: args[1] };
+    case "neg":
+      return { kind: "neg", arg: args[0] };
+    case "abs":
+      return { kind: "abs", arg: args[0] };
+    case "min":
+      if (args.length === 1) {
+        return { kind: "minArray", array: args[0] };
+      }
+      return { kind: "min", args };
+    case "max":
+      if (args.length === 1) {
+        return { kind: "maxArray", array: args[0] };
+      }
+      return { kind: "max", args };
+    // v0.3.2: sum array aggregation
+    case "sum":
+      return { kind: "sumArray", array: args[0] };
+    case "floor":
+      return { kind: "floor", arg: args[0] };
+    case "ceil":
+      return { kind: "ceil", arg: args[0] };
+    case "round":
+      return { kind: "round", arg: args[0] };
+    case "sqrt":
+      return { kind: "sqrt", arg: args[0] };
+    case "pow":
+      return { kind: "pow", base: args[0], exponent: args[1] };
+    // ============ Comparison ============
+    case "eq":
+      return { kind: "eq", left: args[0], right: args[1] };
+    case "neq":
+      return { kind: "neq", left: args[0], right: args[1] };
+    case "gt":
+      return { kind: "gt", left: args[0], right: args[1] };
+    case "gte":
+      return { kind: "gte", left: args[0], right: args[1] };
+    case "lt":
+      return { kind: "lt", left: args[0], right: args[1] };
+    case "lte":
+      return { kind: "lte", left: args[0], right: args[1] };
+    // ============ Logical ============
+    case "and":
+      return { kind: "and", args };
+    case "or":
+      return { kind: "or", args };
+    case "not":
+      return { kind: "not", arg: args[0] };
+    // ============ Type Checking ============
+    case "isNull":
+      return { kind: "isNull", arg: args[0] };
+    case "isNotNull":
+      return { kind: "not", arg: { kind: "isNull", arg: args[0] } };
+    case "typeof":
+      return { kind: "typeof", arg: args[0] };
+    case "coalesce":
+      return { kind: "coalesce", args };
+    // ============ String ============
+    case "concat":
+      return { kind: "concat", args };
+    case "trim":
+      return { kind: "trim", str: args[0] };
+    case "lower":
+    case "toLowerCase":
+      return { kind: "toLowerCase", str: args[0] };
+    case "upper":
+    case "toUpperCase":
+      return { kind: "toUpperCase", str: args[0] };
+    case "strlen":
+    case "strLen":
+      return { kind: "strLen", str: args[0] };
+    case "substr":
+    case "substring":
+      return args[2] ? { kind: "substring", str: args[0], start: args[1], end: args[2] } : { kind: "substring", str: args[0], start: args[1] };
+    case "toString":
+      return { kind: "toString", arg: args[0] };
+    // ============ Collection ============
+    case "len":
+    case "length":
+      return { kind: "len", arg: args[0] };
+    case "at":
+      return { kind: "at", array: args[0], index: args[1] };
+    case "first":
+      return { kind: "first", array: args[0] };
+    case "last":
+      return { kind: "last", array: args[0] };
+    case "slice":
+      return args[2] ? { kind: "slice", array: args[0], start: args[1], end: args[2] } : { kind: "slice", array: args[0], start: args[1] };
+    case "includes":
+      return { kind: "includes", array: args[0], item: args[1] };
+    case "filter":
+      return { kind: "filter", array: args[0], predicate: args[1] };
+    case "map":
+      return { kind: "map", array: args[0], mapper: args[1] };
+    case "find":
+      return { kind: "find", array: args[0], predicate: args[1] };
+    case "every":
+      return { kind: "every", array: args[0], predicate: args[1] };
+    case "some":
+      return { kind: "some", array: args[0], predicate: args[1] };
+    case "append":
+      return { kind: "append", array: args[0], items: args.slice(1) };
+    // ============ Object ============
+    case "keys":
+      return { kind: "keys", obj: args[0] };
+    case "values":
+      return { kind: "values", obj: args[0] };
+    case "entries":
+      return { kind: "entries", obj: args[0] };
+    case "merge":
+      return { kind: "merge", objects: args };
+    // ============ Conditional ============
+    case "if":
+    case "cond":
+      return { kind: "if", cond: args[0], then: args[1], else: args[2] };
+    // ============ Unknown Function ============
+    default:
+      return {
+        kind: "object",
+        fields: {
+          __call: { kind: "lit", value: name },
+          __args: { kind: "lit", value: args }
+        }
+      };
+  }
+}
+
 // src/generator/lowering.ts
 import {
   hashSchemaSync,
@@ -239,16 +556,7 @@ function lowerSystemValues(schema) {
     }
     lowered = true;
     for (const slot of ctx.slots.values()) {
-      result.state.fields[slot.valueSlot] = {
-        type: systemValueType(slot.key),
-        required: true,
-        default: null
-      };
-      result.state.fields[slot.intentSlot] = {
-        type: "string",
-        required: true,
-        default: null
-      };
+      ensureSystemSlotFields(result.state.fields, actionName, slot);
     }
     result.actions[actionName] = {
       ...action,
@@ -283,6 +591,40 @@ function systemValueType(key) {
 function normalizeSystemKeyForSlot(key) {
   return key.replaceAll(".", "_");
 }
+function ensureObjectField(fields, name) {
+  const existing = fields[name];
+  if (existing && existing.type === "object") {
+    existing.required = false;
+    existing.default ??= {};
+    existing.fields ??= {};
+    return existing;
+  }
+  const created = {
+    type: "object",
+    required: false,
+    default: {},
+    fields: {}
+  };
+  fields[name] = created;
+  return created;
+}
+function ensureSystemSlotFields(rootFields, actionName, slot) {
+  const melField = ensureObjectField(rootFields, "$mel");
+  const sysField = ensureObjectField(melField.fields ?? (melField.fields = {}), "sys");
+  const actionField = ensureObjectField(sysField.fields ?? (sysField.fields = {}), actionName);
+  const keyField = ensureObjectField(actionField.fields ?? (actionField.fields = {}), slot.normalizedKey);
+  const keyFields = keyField.fields ?? (keyField.fields = {});
+  keyFields.intent = {
+    type: "string",
+    required: false,
+    default: null
+  };
+  keyFields.value = {
+    type: systemValueType(slot.key),
+    required: false,
+    default: null
+  };
+}
 function toPatchPath(path) {
   return semanticPathToPatchPath(path);
 }
@@ -324,8 +666,9 @@ function collectSystemRefsFromExpr(expr, ctx) {
       const normalizedKey = normalizeSystemKeyForSlot(key);
       ctx.slots.set(key, {
         key,
-        valueSlot: `__sys__${ctx.actionName}_${normalizedKey}_value`,
-        intentSlot: `__sys__${ctx.actionName}_${normalizedKey}_intent`
+        normalizedKey,
+        valuePath: `$mel.sys.${ctx.actionName}.${normalizedKey}.value`,
+        intentPath: `$mel.sys.${ctx.actionName}.${normalizedKey}.intent`
       });
     }
     return;
@@ -362,7 +705,7 @@ function lowerFlow(flow, ctx) {
       kind: "if",
       cond: {
         kind: "neq",
-        left: { kind: "get", path: slot.intentSlot },
+        left: { kind: "get", path: slot.intentPath },
         right: { kind: "get", path: "meta.intentId" }
       },
       then: {
@@ -371,7 +714,7 @@ function lowerFlow(flow, ctx) {
           {
             kind: "patch",
             op: "set",
-            path: toPatchPath(slot.intentSlot),
+            path: toPatchPath(slot.intentPath),
             value: { kind: "get", path: "meta.intentId" }
           },
           {
@@ -379,7 +722,7 @@ function lowerFlow(flow, ctx) {
             type: "system.get",
             params: {
               key: { kind: "lit", value: slot.key },
-              into: { kind: "lit", value: slot.valueSlot }
+              into: { kind: "lit", value: slot.valuePath }
             }
           }
         ]
@@ -391,7 +734,7 @@ function lowerFlow(flow, ctx) {
   for (const slot of ctx.slots.values()) {
     readinessConditions.push({
       kind: "eq",
-      left: { kind: "get", path: slot.intentSlot },
+      left: { kind: "get", path: slot.intentPath },
       right: { kind: "get", path: "meta.intentId" }
     });
   }
@@ -453,7 +796,7 @@ function transformExpr(expr, ctx) {
     const key = expr.path.slice("$system.".length);
     const slot = ctx.slots.get(key);
     if (slot) {
-      return { kind: "get", path: slot.valueSlot };
+      return { kind: "get", path: slot.valuePath };
     }
   }
   switch (expr.kind) {
@@ -1049,134 +1392,6 @@ function renderAsDomain(domainName, fragments, options) {
   return lines.join("\n");
 }
 
-// src/lowering/context.ts
-var DEFAULT_SCHEMA_CONTEXT = {
-  mode: "schema",
-  allowSysPaths: { prefixes: ["meta", "input"] },
-  fnTableVersion: "1.0",
-  allowItem: false
-};
-var DEFAULT_ACTION_CONTEXT = {
-  mode: "action",
-  allowSysPaths: { prefixes: ["meta", "input"] },
-  fnTableVersion: "1.0",
-  allowItem: false
-};
-var EFFECT_ARGS_CONTEXT = {
-  mode: "action",
-  allowSysPaths: { prefixes: ["meta", "input"] },
-  fnTableVersion: "1.0",
-  allowItem: true
-};
-var DEFAULT_PATCH_CONTEXT = {
-  allowSysPaths: { prefixes: ["meta", "input"] },
-  fnTableVersion: "1.0"
-};
-
-// src/lowering/lower-patch.ts
-function lowerPatchFragments(fragments, ctx) {
-  return fragments.map((fragment) => lowerPatchFragment(fragment, ctx));
-}
-function lowerPatchFragment(fragment, ctx) {
-  const condition = fragment.condition ? lowerExprNode(fragment.condition, createExprContext(ctx, "action")) : void 0;
-  const op = lowerPatchOp(fragment.op, ctx);
-  return {
-    fragmentId: fragment.fragmentId,
-    condition,
-    op,
-    confidence: fragment.confidence
-  };
-}
-function lowerPatchOp(op, ctx) {
-  switch (op.kind) {
-    case "addType":
-      return {
-        kind: "addType",
-        typeName: op.typeName,
-        typeExpr: lowerTypeExpr(op.typeExpr)
-      };
-    case "addField":
-      return {
-        kind: "addField",
-        typeName: op.typeName,
-        field: {
-          name: op.field.name,
-          type: lowerTypeExpr(op.field.type),
-          optional: op.field.optional,
-          defaultValue: op.field.defaultValue
-        }
-      };
-    case "setFieldType":
-      return {
-        kind: "setFieldType",
-        path: op.path,
-        typeExpr: lowerTypeExpr(op.typeExpr)
-      };
-    case "setDefaultValue":
-      return {
-        kind: "setDefaultValue",
-        path: op.path,
-        value: op.value
-      };
-    case "addConstraint":
-      return {
-        kind: "addConstraint",
-        targetPath: op.targetPath,
-        rule: lowerExprNode(op.rule, createExprContext(ctx, "schema")),
-        message: op.message
-      };
-    case "addComputed":
-      return {
-        kind: "addComputed",
-        name: op.name,
-        expr: lowerExprNode(op.expr, createExprContext(ctx, "schema")),
-        deps: op.deps
-      };
-    case "addActionAvailable":
-      return {
-        kind: "addActionAvailable",
-        actionName: op.actionName,
-        expr: lowerExprNode(op.expr, createExprContext(ctx, "schema"))
-      };
-  }
-}
-function lowerTypeExpr(typeExpr) {
-  switch (typeExpr.kind) {
-    case "primitive":
-      return { kind: "primitive", name: typeExpr.name };
-    case "array":
-      return { kind: "array", element: lowerTypeExpr(typeExpr.element) };
-    case "object":
-      return {
-        kind: "object",
-        fields: typeExpr.fields.map((f) => ({
-          name: f.name,
-          type: lowerTypeExpr(f.type),
-          optional: f.optional
-        }))
-      };
-    case "union":
-      return {
-        kind: "union",
-        members: typeExpr.members.map(lowerTypeExpr)
-      };
-    case "literal":
-      return { kind: "literal", value: typeExpr.value };
-    case "ref":
-      return { kind: "ref", name: typeExpr.name };
-  }
-}
-function createExprContext(patchCtx, mode) {
-  return {
-    mode,
-    allowSysPaths: patchCtx.allowSysPaths,
-    fnTableVersion: patchCtx.fnTableVersion,
-    actionName: patchCtx.actionName,
-    allowItem: false
-    // Only true for effect.args (not in schema ops)
-  };
-}
-
 // src/evaluation/context.ts
 import { parsePath as parsePath2 } from "@manifesto-ai/core";
 function createEvaluationContext(options) {
@@ -1259,6 +1474,8 @@ function evaluateNode(expr, ctx) {
       return evaluateDiv(expr.left, expr.right, ctx);
     case "mod":
       return evaluateMod(expr.left, expr.right, ctx);
+    case "neg":
+      return evaluateNeg(expr.arg, ctx);
     // String
     case "concat":
       return evaluateConcat(expr.args, ctx);
@@ -1465,6 +1682,10 @@ function evaluateMod(left, right, ctx) {
   }
   return l % r;
 }
+function evaluateNeg(arg, ctx) {
+  const value = evaluateNode(arg, ctx);
+  return typeof value === "number" ? -value : null;
+}
 function evaluateConcat(args, ctx) {
   const values = [];
   for (const arg of args) {
@@ -1653,7 +1874,8 @@ function evaluateAppend(array, items, ctx) {
 }
 function evaluateObject(fields, ctx) {
   const result = {};
-  for (const [key, value] of Object.entries(fields)) {
+  for (const key of Object.keys(fields).sort(compareUnicodeCodePoints)) {
+    const value = fields[key];
     result[key] = evaluateNode(value, ctx);
   }
   return result;
@@ -1670,21 +1892,21 @@ function evaluateKeys(obj, ctx) {
   if (o === null || typeof o !== "object" || Array.isArray(o)) {
     return null;
   }
-  return Object.keys(o);
+  return Object.keys(o).sort(compareUnicodeCodePoints);
 }
 function evaluateValues(obj, ctx) {
   const o = evaluateNode(obj, ctx);
   if (o === null || typeof o !== "object" || Array.isArray(o)) {
     return null;
   }
-  return Object.values(o);
+  return Object.keys(o).sort(compareUnicodeCodePoints).map((key) => o[key]);
 }
 function evaluateEntries(obj, ctx) {
   const o = evaluateNode(obj, ctx);
   if (o === null || typeof o !== "object" || Array.isArray(o)) {
     return null;
   }
-  return Object.entries(o);
+  return Object.keys(o).sort(compareUnicodeCodePoints).map((key) => [key, o[key]]);
 }
 function evaluateMerge(objects, ctx) {
   const result = {};
@@ -2055,13 +2277,26 @@ function compile(source, options = {}) {
     };
   }
   const diagnostics = [];
-  if (!options.skipSemanticAnalysis && parseResult.program) {
-    const scopeResult = analyzeScope(parseResult.program);
-    const validateResult = validateSemantics(parseResult.program);
+  const analyzeStart = performance.now();
+  const flowResult = validateAndExpandFlows(parseResult.program);
+  diagnostics.push(...flowResult.diagnostics);
+  if (!options.skipSemanticAnalysis) {
+    const scopeResult = analyzeScope(flowResult.program);
+    const validateResult = validateSemantics(flowResult.program);
     diagnostics.push(...scopeResult.diagnostics, ...validateResult.diagnostics);
   }
+  trace.push({ phase: "analyze", durationMs: performance.now() - analyzeStart });
+  if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return {
+      schema: null,
+      trace,
+      warnings: diagnostics.filter((diagnostic) => diagnostic.severity === "warning"),
+      errors: diagnostics.filter((diagnostic) => diagnostic.severity === "error"),
+      success: false
+    };
+  }
   const generateStart = performance.now();
-  const genResult = generate(parseResult.program);
+  const genResult = generate(flowResult.program);
   diagnostics.push(...genResult.diagnostics);
   trace.push({ phase: "generate", durationMs: performance.now() - generateStart });
   if (options.skipSemanticAnalysis) {
@@ -2146,6 +2381,7 @@ export {
   formatDiagnosticCode,
   formatDiagnostics,
   generate,
+  generateCanonical,
   getBinaryPrecedence,
   getDiagnosticInfo,
   getKeywordKind,