@manifesto-ai/compiler 1.6.2 → 1.7.0

package/dist/index.js

@@ -1,44 +1,2190 @@
-/**
- * @manifesto-ai/compiler
- *
- * MEL (Manifesto Expression Language) compiler.
- * Provides lexer, parser, analyzer, lowering, evaluation, and rendering.
- */
-// ════════════════════════════════════════════════════════════════════════════
-// Lexer (MEL source → tokens)
-// ════════════════════════════════════════════════════════════════════════════
-export * from "./lexer/index.js";
-// ════════════════════════════════════════════════════════════════════════════
-// Parser (tokens → AST)
-// ════════════════════════════════════════════════════════════════════════════
-export * from "./parser/index.js";
-// ════════════════════════════════════════════════════════════════════════════
-// Analyzer (AST validation and scope analysis)
-// ════════════════════════════════════════════════════════════════════════════
-export * from "./analyzer/index.js";
-// ════════════════════════════════════════════════════════════════════════════
-// Diagnostics
-// ════════════════════════════════════════════════════════════════════════════
-export * from "./diagnostics/index.js";
-// ════════════════════════════════════════════════════════════════════════════
-// Generator (AST → IR)
-// ════════════════════════════════════════════════════════════════════════════
-export * from "./generator/index.js";
-// ════════════════════════════════════════════════════════════════════════════
-// MEL Renderer (PatchFragment → MEL text)
-// Re-export with namespace to avoid ExprNode conflict with parser
-// ════════════════════════════════════════════════════════════════════════════
-export { renderTypeExpr, renderTypeField, renderValue, renderExprNode, renderPatchOp, extractTypeName, renderFragment, renderFragments, renderFragmentsByKind, renderAsDomain, } from "./renderer/index.js";
-// ════════════════════════════════════════════════════════════════════════════
-// Lowering (MEL IR → Core IR)
-// ════════════════════════════════════════════════════════════════════════════
-export * from "./lowering/index.js";
-// ════════════════════════════════════════════════════════════════════════════
-// Evaluation (Core IR → Concrete Values)
-// ════════════════════════════════════════════════════════════════════════════
-export * from "./evaluation/index.js";
-// ════════════════════════════════════════════════════════════════════════════
-// Compile API (MEL Text Ingest)
-// ════════════════════════════════════════════════════════════════════════════
-export * from "./api/index.js";
+import {
+  KEYWORDS,
+  Lexer,
+  LoweringError,
+  Parser,
+  Precedence,
+  RESERVED_KEYWORDS,
+  Scope,
+  ScopeAnalyzer,
+  SemanticValidator,
+  analyzeScope,
+  compileMelDomain,
+  compileMelPatch,
+  createError,
+  createInfo,
+  createLocation,
+  createPointLocation,
+  createPosition,
+  createToken,
+  createWarning,
+  filterBySeverity,
+  generate,
+  getBinaryPrecedence,
+  getKeywordKind,
+  hasErrors,
+  invalidKindForContext,
+  invalidShape,
+  invalidSysPath,
+  isBinaryOp,
+  isError,
+  isExprNode,
+  isKeyword,
+  isReserved,
+  isRightAssociative,
+  isStmtNode,
+  isUnaryOp,
+  lowerExprNode,
+  lowerRuntimePatch,
+  lowerRuntimePatches,
+  mergeLocations,
+  normalizeExpr,
+  normalizeFunctionCall,
+  parse,
+  tokenToBinaryOp,
+  tokenize,
+  unknownCallFn,
+  unknownNodeKind,
+  unsupportedBase,
+  validateSemantics
+} from "./chunk-QP2LGMBA.js";
+
+// src/diagnostics/codes.ts
+var DIAGNOSTIC_CODES = {
+  // ============ Syntax Errors (E0xx) ============
+  E001: {
+    code: "E001",
+    message: "$system.* cannot be used in computed expressions (non-deterministic)",
+    category: "semantic"
+  },
+  E002: {
+    code: "E002",
+    message: "$system.* cannot be used in state initializers",
+    category: "semantic"
+  },
+  E003: {
+    code: "E003",
+    message: "Invalid $system reference",
+    category: "semantic"
+  },
+  E004: {
+    code: "E004",
+    message: "Identifier starts with reserved prefix '__sys__'",
+    category: "syntax"
+  },
+  // ============ v0.3.3 Errors (E0xx) ============
+  E005: {
+    code: "E005",
+    message: "available expression must be pure (no Effects, no $system.*)",
+    category: "semantic"
+  },
+  E006: {
+    code: "E006",
+    message: "fail must be inside a guard (when or once)",
+    category: "semantic"
+  },
+  E007: {
+    code: "E007",
+    message: "stop must be inside a guard (when or once)",
+    category: "semantic"
+  },
+  E008: {
+    code: "E008",
+    message: "stop message suggests waiting/pending - use 'Already processed' style instead",
+    category: "semantic"
+  },
+  E009: {
+    code: "E009",
+    message: "Primitive aggregation (sum, min, max) only allowed in computed",
+    category: "semantic"
+  },
+  E010: {
+    code: "E010",
+    message: "Primitive aggregation does not allow composition - use direct reference only",
+    category: "semantic"
+  },
+  E011: {
+    code: "E011",
+    message: "reduce/fold/scan is forbidden - use sum, min, max for aggregation",
+    category: "semantic"
+  },
+  // ============ Scope Errors (E1xx) ============
+  E_UNDEFINED: {
+    code: "E_UNDEFINED",
+    message: "Undefined identifier",
+    category: "semantic"
+  },
+  E_DUPLICATE: {
+    code: "E_DUPLICATE",
+    message: "Duplicate identifier",
+    category: "semantic"
+  },
+  E_INVALID_ACCESS: {
+    code: "E_INVALID_ACCESS",
+    message: "Invalid access to identifier in this context",
+    category: "semantic"
+  },
+  // ============ Statement Errors (E2xx) ============
+  E_UNGUARDED_STMT: {
+    code: "E_UNGUARDED_STMT",
+    message: "Statement must be inside a guard (when or once)",
+    category: "semantic"
+  },
+  E_UNGUARDED_PATCH: {
+    code: "E_UNGUARDED_PATCH",
+    message: "Patch must be inside a guard",
+    category: "semantic"
+  },
+  E_UNGUARDED_EFFECT: {
+    code: "E_UNGUARDED_EFFECT",
+    message: "Effect must be inside a guard",
+    category: "semantic"
+  },
+  // ============ Type Errors (E3xx) ============
+  E_ARG_COUNT: {
+    code: "E_ARG_COUNT",
+    message: "Wrong number of arguments",
+    category: "type"
+  },
+  E_TYPE_MISMATCH: {
+    code: "E_TYPE_MISMATCH",
+    message: "Type mismatch",
+    category: "type"
+  },
+  // ============ Warnings (W0xx) ============
+  W_NON_BOOL_COND: {
+    code: "W_NON_BOOL_COND",
+    message: "Condition may not be boolean",
+    category: "semantic"
+  },
+  W_UNUSED: {
+    code: "W_UNUSED",
+    message: "Unused identifier",
+    category: "semantic"
+  },
+  W012: {
+    code: "W012",
+    message: "Anonymous object type in state field - use named type declaration instead",
+    category: "type"
+  },
+  // ============ Lexer Errors ============
+  MEL_LEXER: {
+    code: "MEL_LEXER",
+    message: "Lexer error",
+    category: "syntax"
+  },
+  // ============ Parser Errors ============
+  MEL_PARSER: {
+    code: "MEL_PARSER",
+    message: "Parser error",
+    category: "syntax"
+  }
+};
+function getDiagnosticInfo(code) {
+  return DIAGNOSTIC_CODES[code];
+}
+function formatDiagnosticCode(code) {
+  const info = DIAGNOSTIC_CODES[code];
+  if (info) {
+    return `${code}: ${info.message}`;
+  }
+  return code;
+}
+
+// src/diagnostics/format.ts
+function formatDiagnostic(diagnostic, source) {
+  const { code, message, location } = diagnostic;
+  if (!location || location.start.line === 0 && location.start.column === 0) {
+    return `[${code}] ${message}`;
+  }
+  const { line, column } = location.start;
+  const header = `[${code}] ${message} (${line}:${column})`;
+  if (!source) {
+    return header;
+  }
+  const sourceLines = source.split("\n");
+  const lineContent = sourceLines[line - 1];
+  if (!lineContent) {
+    return header;
+  }
+  const lineNumStr = String(line).padStart(4, " ");
+  const sourceLine = `${lineNumStr} | ${lineContent}`;
+  const underlineLen = Math.max(
+    1,
+    location.end.line === location.start.line ? Math.min(location.end.column - column, lineContent.length - column + 1) : 1
+  );
+  const padding = " ".repeat(lineNumStr.length + 3 + column - 1);
+  const underline = `${padding}${"^".repeat(underlineLen)}`;
+  return `${header}
+${sourceLine}
+${underline}`;
+}
+function formatDiagnostics(diagnostics, source) {
+  return diagnostics.map((d) => formatDiagnostic(d, source)).join("\n\n");
+}
+
+// src/generator/lowering.ts
+import {
+  hashSchemaSync,
+  semanticPathToPatchPath
+} from "@manifesto-ai/core";
+function lowerSystemValues(schema) {
+  const result = structuredClone(schema);
+  let lowered = false;
+  for (const [actionName, action] of Object.entries(result.actions)) {
+    const ctx = createContext(actionName);
+    collectSystemRefs(action.flow, ctx);
+    if (ctx.slots.size === 0) {
+      continue;
+    }
+    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
+      };
+    }
+    result.actions[actionName] = {
+      ...action,
+      flow: lowerFlow(action.flow, ctx)
+    };
+  }
+  if (!lowered) {
+    return result;
+  }
+  const { hash: _hash, ...schemaWithoutHash } = result;
+  const nextHash = hashSchemaSync(schemaWithoutHash);
+  return {
+    ...schemaWithoutHash,
+    hash: nextHash
+  };
+}
+function createContext(actionName) {
+  return {
+    actionName,
+    slots: /* @__PURE__ */ new Map()
+  };
+}
+function systemValueType(key) {
+  switch (key) {
+    case "timestamp":
+    case "time.now":
+      return "number";
+    default:
+      return "string";
+  }
+}
+function normalizeSystemKeyForSlot(key) {
+  return key.replaceAll(".", "_");
+}
+function toPatchPath(path) {
+  return semanticPathToPatchPath(path);
+}
+function collectSystemRefs(flow, ctx) {
+  switch (flow.kind) {
+    case "seq":
+      for (const step of flow.steps) {
+        collectSystemRefs(step, ctx);
+      }
+      break;
+    case "if":
+      collectSystemRefsFromExpr(flow.cond, ctx);
+      collectSystemRefs(flow.then, ctx);
+      if (flow.else) {
+        collectSystemRefs(flow.else, ctx);
+      }
+      break;
+    case "patch":
+      if (flow.value) {
+        collectSystemRefsFromExpr(flow.value, ctx);
+      }
+      break;
+    case "effect":
+      for (const param of Object.values(flow.params)) {
+        collectSystemRefsFromExpr(param, ctx);
+      }
+      break;
+    case "fail":
+      if (flow.message) {
+        collectSystemRefsFromExpr(flow.message, ctx);
+      }
+      break;
+  }
+}
+function collectSystemRefsFromExpr(expr, ctx) {
+  if (expr.kind === "get" && expr.path.startsWith("$system.")) {
+    const key = expr.path.slice("$system.".length);
+    if (!ctx.slots.has(key)) {
+      const normalizedKey = normalizeSystemKeyForSlot(key);
+      ctx.slots.set(key, {
+        key,
+        valueSlot: `__sys__${ctx.actionName}_${normalizedKey}_value`,
+        intentSlot: `__sys__${ctx.actionName}_${normalizedKey}_intent`
+      });
+    }
+    return;
+  }
+  if (expr.kind === "object") {
+    for (const value of Object.values(expr.fields)) {
+      if (value && typeof value === "object" && "kind" in value) {
+        collectSystemRefsFromExpr(value, ctx);
+      }
+    }
+    return;
+  }
+  for (const value of Object.values(expr)) {
+    if (typeof value === "object" && value !== null) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === "object" && item !== null && "kind" in item) {
+            collectSystemRefsFromExpr(item, ctx);
+          }
+        }
+      } else if ("kind" in value) {
+        collectSystemRefsFromExpr(value, ctx);
+      }
+    }
+  }
+}
+function lowerFlow(flow, ctx) {
+  if (ctx.slots.size === 0) {
+    return flow;
+  }
+  const acquisitionSteps = [];
+  for (const slot of ctx.slots.values()) {
+    const acquisitionFlow = {
+      kind: "if",
+      cond: {
+        kind: "neq",
+        left: { kind: "get", path: slot.intentSlot },
+        right: { kind: "get", path: "meta.intentId" }
+      },
+      then: {
+        kind: "seq",
+        steps: [
+          {
+            kind: "patch",
+            op: "set",
+            path: toPatchPath(slot.intentSlot),
+            value: { kind: "get", path: "meta.intentId" }
+          },
+          {
+            kind: "effect",
+            type: "system.get",
+            params: {
+              key: { kind: "lit", value: slot.key },
+              into: { kind: "lit", value: slot.valueSlot }
+            }
+          }
+        ]
+      }
+    };
+    acquisitionSteps.push(acquisitionFlow);
+  }
+  const readinessConditions = [];
+  for (const slot of ctx.slots.values()) {
+    readinessConditions.push({
+      kind: "eq",
+      left: { kind: "get", path: slot.intentSlot },
+      right: { kind: "get", path: "meta.intentId" }
+    });
+  }
+  const readinessCond = readinessConditions.length === 1 ? readinessConditions[0] : { kind: "and", args: readinessConditions };
+  const transformedFlow = transformFlow(flow, ctx);
+  const guardedFlow = {
+    kind: "if",
+    cond: readinessCond,
+    then: transformedFlow
+  };
+  return {
+    kind: "seq",
+    steps: [...acquisitionSteps, guardedFlow]
+  };
+}
+function transformFlow(flow, ctx) {
+  switch (flow.kind) {
+    case "seq":
+      return {
+        kind: "seq",
+        steps: flow.steps.map((s) => transformFlow(s, ctx))
+      };
+    case "if":
+      return {
+        kind: "if",
+        cond: transformExpr(flow.cond, ctx),
+        then: transformFlow(flow.then, ctx),
+        else: flow.else ? transformFlow(flow.else, ctx) : void 0
+      };
+    case "patch":
+      return {
+        kind: "patch",
+        op: flow.op,
+        path: flow.path,
+        value: flow.value ? transformExpr(flow.value, ctx) : void 0
+      };
+    case "effect":
+      const params = {};
+      for (const [key, value] of Object.entries(flow.params)) {
+        params[key] = transformExpr(value, ctx);
+      }
+      return {
+        kind: "effect",
+        type: flow.type,
+        params
+      };
+    case "fail":
+      return {
+        kind: "fail",
+        code: flow.code,
+        message: flow.message ? transformExpr(flow.message, ctx) : void 0
+      };
+    default:
+      return flow;
+  }
+}
+function transformExpr(expr, ctx) {
+  if (expr.kind === "get" && expr.path.startsWith("$system.")) {
+    const key = expr.path.slice("$system.".length);
+    const slot = ctx.slots.get(key);
+    if (slot) {
+      return { kind: "get", path: slot.valueSlot };
+    }
+  }
+  switch (expr.kind) {
+    case "eq":
+    case "neq":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+    case "add":
+    case "sub":
+    case "mul":
+    case "div":
+    case "mod":
+      return {
+        kind: expr.kind,
+        left: transformExpr(expr.left, ctx),
+        right: transformExpr(expr.right, ctx)
+      };
+    case "and":
+    case "or":
+    case "coalesce":
+    case "concat":
+    case "min":
+    case "max":
+    case "merge":
+      return {
+        kind: expr.kind,
+        args: expr.args.map((a) => transformExpr(a, ctx))
+      };
+    case "not":
+    case "neg":
+    case "abs":
+    case "floor":
+    case "ceil":
+    case "round":
+    case "isNull":
+    case "typeof":
+    case "toString":
+    case "len":
+    case "keys":
+    case "values":
+    case "entries":
+    case "first":
+    case "last":
+      return {
+        kind: expr.kind,
+        arg: transformExpr(expr.arg, ctx)
+      };
+    case "trim":
+    case "toLowerCase":
+    case "toUpperCase":
+    case "strLen":
+      return {
+        kind: expr.kind,
+        str: transformExpr(expr.str, ctx)
+      };
+    case "at":
+    case "includes":
+      return {
+        kind: expr.kind,
+        array: transformExpr(expr.array, ctx),
+        index: transformExpr(expr.index ?? expr.item, ctx)
+      };
+    case "filter":
+    case "map":
+    case "find":
+    case "every":
+    case "some":
+      return {
+        kind: expr.kind,
+        array: transformExpr(expr.array, ctx),
+        predicate: transformExpr(expr.predicate ?? expr.mapper, ctx)
+      };
+    case "if":
+      return {
+        kind: "if",
+        cond: transformExpr(expr.cond, ctx),
+        then: transformExpr(expr.then, ctx),
+        else: transformExpr(expr.else, ctx)
+      };
+    case "field":
+      return {
+        kind: "field",
+        object: transformExpr(expr.object, ctx),
+        property: expr.property
+      };
+    case "object":
+      const fields = {};
+      for (const [key, value] of Object.entries(expr.fields)) {
+        fields[key] = transformExpr(value, ctx);
+      }
+      return { kind: "object", fields };
+    case "append":
+      return {
+        kind: "append",
+        array: transformExpr(expr.array, ctx),
+        items: expr.items.map((i) => transformExpr(i, ctx))
+      };
+    default:
+      return expr;
+  }
+}
+
+// src/renderer/type-expr.ts
+function renderTypeExpr(typeExpr) {
+  switch (typeExpr.kind) {
+    case "primitive":
+      return typeExpr.name;
+    case "literal":
+      return renderLiteralValue(typeExpr.value);
+    case "ref":
+      return typeExpr.name;
+    case "array":
+      return `Array<${renderTypeExpr(typeExpr.element)}>`;
+    case "record":
+      return `Record<${renderTypeExpr(typeExpr.key)}, ${renderTypeExpr(typeExpr.value)}>`;
+    case "union":
+      return renderUnion(typeExpr.members);
+    case "object":
+      return renderObjectType(typeExpr.fields);
+  }
+}
+function renderLiteralValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return `"${escapeString(value)}"`;
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  return String(value);
+}
+function renderUnion(members) {
+  if (members.length === 0) {
+    return "never";
+  }
+  return members.map(renderTypeExpr).join(" | ");
+}
+function renderObjectType(fields) {
+  if (fields.length === 0) {
+    return "{}";
+  }
+  const fieldStrings = fields.map((field) => {
+    const optional = field.optional ? "?" : "";
+    return `${field.name}${optional}: ${renderTypeExpr(field.type)}`;
+  });
+  return `{ ${fieldStrings.join(", ")} }`;
+}
+function renderTypeField(field, defaultValue) {
+  const typeStr = renderTypeExpr(field.type);
+  if (defaultValue !== void 0) {
+    return `${field.name}: ${typeStr} = ${renderValue(defaultValue)}`;
+  }
+  if (field.optional) {
+    return `${field.name}?: ${typeStr}`;
+  }
+  return `${field.name}: ${typeStr}`;
+}
+function renderValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return `"${escapeString(value)}"`;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (Array.isArray(value)) {
+    const items = value.map(renderValue).join(", ");
+    return `[${items}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${k}: ${renderValue(v)}`).join(", ");
+    return `{ ${entries} }`;
+  }
+  return String(value);
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+
+// src/renderer/expr-node.ts
+function renderExprNode(expr) {
+  switch (expr.kind) {
+    // Literals
+    case "lit":
+      return renderLiteral(expr.value);
+    case "get":
+      return renderPath(expr.path);
+    // Comparison (binary)
+    case "eq":
+      return `eq(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    case "neq":
+      return `neq(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    case "gt":
+      return `gt(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    case "gte":
+      return `gte(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    case "lt":
+      return `lt(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    case "lte":
+      return `lte(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    // Logical
+    case "and":
+      if (!expr.args || !Array.isArray(expr.args)) {
+        return `and(/* malformed: args undefined */)`;
+      }
+      return `and(${expr.args.map(renderExprNode).join(", ")})`;
+    case "or":
+      if (!expr.args || !Array.isArray(expr.args)) {
+        return `or(/* malformed: args undefined */)`;
+      }
+      return `or(${expr.args.map(renderExprNode).join(", ")})`;
+    case "not":
+      if (!expr.arg) {
+        return `not(/* malformed: arg undefined */)`;
+      }
+      return `not(${renderExprNode(expr.arg)})`;
+    // Conditional
+    case "if":
+      return `if(${renderExprNode(expr.cond)}, ${renderExprNode(expr.then)}, ${renderExprNode(expr.else)})`;
+    // Arithmetic
+    case "add":
+      return `add(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    case "sub":
+      return `sub(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    case "mul":
+      return `mul(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    case "div":
+      return `div(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    case "mod":
+      return `mod(${renderExprNode(expr.left)}, ${renderExprNode(expr.right)})`;
+    // String
+    case "concat":
+      if (!expr.args || !Array.isArray(expr.args)) {
+        return `concat(/* malformed: args undefined */)`;
+      }
+      return `concat(${expr.args.map(renderExprNode).join(", ")})`;
+    case "substring":
+      if (expr.end !== void 0) {
+        return `substring(${renderExprNode(expr.str)}, ${renderExprNode(expr.start)}, ${renderExprNode(expr.end)})`;
+      }
+      return `substring(${renderExprNode(expr.str)}, ${renderExprNode(expr.start)})`;
+    case "trim":
+      return `trim(${renderExprNode(expr.str)})`;
+    // Collection
+    case "len":
+      return `len(${renderExprNode(expr.arg)})`;
+    case "at":
+      return `at(${renderExprNode(expr.array)}, ${renderExprNode(expr.index)})`;
+    case "first":
+      return `first(${renderExprNode(expr.array)})`;
+    case "last":
+      return `last(${renderExprNode(expr.array)})`;
+    case "slice":
+      if (expr.end !== void 0) {
+        return `slice(${renderExprNode(expr.array)}, ${renderExprNode(expr.start)}, ${renderExprNode(expr.end)})`;
+      }
+      return `slice(${renderExprNode(expr.array)}, ${renderExprNode(expr.start)})`;
+    case "includes":
+      return `includes(${renderExprNode(expr.array)}, ${renderExprNode(expr.item)})`;
+    case "filter":
+      return `filter(${renderExprNode(expr.array)}, ${renderExprNode(expr.predicate)})`;
+    case "map":
+      return `map(${renderExprNode(expr.array)}, ${renderExprNode(expr.mapper)})`;
+    case "find":
+      return `find(${renderExprNode(expr.array)}, ${renderExprNode(expr.predicate)})`;
+    case "every":
+      return `every(${renderExprNode(expr.array)}, ${renderExprNode(expr.predicate)})`;
+    case "some":
+      return `some(${renderExprNode(expr.array)}, ${renderExprNode(expr.predicate)})`;
+    case "append":
+      if (!expr.items || !Array.isArray(expr.items)) {
+        return `append(${renderExprNode(expr.array)}, /* malformed: items undefined */)`;
+      }
+      return `append(${renderExprNode(expr.array)}, ${expr.items.map(renderExprNode).join(", ")})`;
+    // Object
+    case "object":
+      return renderObjectExpr(expr.fields);
+    case "field":
+      return `${renderExprNode(expr.object)}.${expr.property}`;
+    case "keys":
+      return `keys(${renderExprNode(expr.obj)})`;
+    case "values":
+      return `values(${renderExprNode(expr.obj)})`;
+    case "entries":
+      return `entries(${renderExprNode(expr.obj)})`;
+    case "merge":
+      if (!expr.objects || !Array.isArray(expr.objects)) {
+        return `merge(/* malformed: objects undefined */)`;
+      }
+      return `merge(${expr.objects.map(renderExprNode).join(", ")})`;
+    // Type
+    case "typeof":
+      return `typeof(${renderExprNode(expr.arg)})`;
+    case "isNull":
+      return `isNull(${renderExprNode(expr.arg)})`;
+    case "coalesce":
+      if (!expr.args || !Array.isArray(expr.args)) {
+        return `coalesce(/* malformed: args undefined */)`;
+      }
+      return `coalesce(${expr.args.map(renderExprNode).join(", ")})`;
+    default:
+      return `/* unknown: ${JSON.stringify(expr)} */`;
+  }
+}
+function renderLiteral(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return `"${escapeString2(value)}"`;
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (Array.isArray(value)) {
+    const items = value.map(renderLiteral).join(", ");
+    return `[${items}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).map(([k, v]) => `${k}: ${renderLiteral(v)}`).join(", ");
+    return `{ ${entries} }`;
+  }
+  return String(value);
+}
+function renderPath(path) {
+  if (path.startsWith("$meta.")) {
+    return path;
+  }
+  if (path.startsWith("$system.")) {
+    return path;
+  }
+  if (path.startsWith("$input.")) {
+    return path;
+  }
+  if (path.startsWith("data.")) {
+    return path.slice(5);
+  }
+  return path;
+}
+function renderObjectExpr(fields) {
+  const entries = Object.entries(fields).map(([key, value]) => `${key}: ${renderExprNode(value)}`).join(", ");
+  return `{ ${entries} }`;
+}
+function escapeString2(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+
+// src/renderer/patch-op.ts
+import { parsePath } from "@manifesto-ai/core";
+var DEFAULT_OPTIONS = {
+  indent: "  ",
+  includeComments: false,
+  commentPrefix: "// "
+};
+function renderPatchOp(op, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  switch (op.kind) {
+    case "addType":
+      return renderAddType(op, opts);
+    case "addField":
+      return renderAddField(op, opts);
+    case "setFieldType":
+      return renderSetFieldType(op, opts);
+    case "setDefaultValue":
+      return renderSetDefaultValue(op, opts);
+    case "addConstraint":
+      return renderAddConstraint(op, opts);
+    case "addComputed":
+      return renderAddComputed(op, opts);
+    case "addActionAvailable":
+      return renderAddActionAvailable(op, opts);
+    default:
+      return `// Unknown operation: ${JSON.stringify(op)}`;
+  }
+}
+function renderAddType(op, opts) {
+  const { indent } = opts;
+  if (op.typeExpr.kind === "object") {
+    const fields = op.typeExpr.fields.map((field) => `${indent}${renderTypeField(field)}`).join("\n");
+    return `type ${op.typeName} {
+${fields}
+}`;
+  }
+  return `type ${op.typeName} = ${renderTypeExpr(op.typeExpr)}`;
+}
+function renderAddField(op, _opts) {
+  const field = op.field;
+  if ("defaultValue" in field && field.defaultValue !== void 0) {
+    return renderTypeField(field, field.defaultValue);
+  }
+  return renderTypeField(field);
+}
+function renderSetFieldType(op, opts) {
+  const typeStr = renderTypeExpr(op.typeExpr);
+  const fieldName = extractFieldName(op.path);
+  const lines = [];
+  if (opts.includeComments) {
+    lines.push(`${opts.commentPrefix}Change ${op.path} type to: ${typeStr}`);
+  }
+  lines.push(`${fieldName}: ${typeStr}`);
+  return lines.join("\n");
+}
+function renderSetDefaultValue(op, opts) {
+  const fieldName = extractFieldName(op.path);
+  const valueStr = renderValue(op.value);
+  const lines = [];
+  if (opts.includeComments) {
+    lines.push(`${opts.commentPrefix}Set default value for ${op.path}`);
+  }
+  lines.push(`${fieldName} = ${valueStr}`);
+  return lines.join("\n");
+}
+function renderAddConstraint(op, opts) {
+  const exprStr = renderExprNode(op.rule);
+  const messageStr = op.message ? ` - "${op.message}"` : "";
+  return `${opts.commentPrefix}Constraint on ${op.targetPath}: ${exprStr}${messageStr}`;
+}
+function renderAddComputed(op, opts) {
+  const exprStr = renderExprNode(op.expr);
+  const lines = [];
+  if (opts.includeComments && op.deps && op.deps.length > 0) {
+    lines.push(`${opts.commentPrefix}Dependencies: ${op.deps.join(", ")}`);
+  }
+  lines.push(`computed ${op.name} = ${exprStr}`);
+  return lines.join("\n");
+}
+function renderAddActionAvailable(op, opts) {
+  const exprStr = renderExprNode(op.expr);
+  const lines = [];
+  if (opts.includeComments) {
+    lines.push(`${opts.commentPrefix}Add availability condition to ${op.actionName}`);
+  }
+  lines.push(`action ${op.actionName}() available when ${exprStr} {`);
+  lines.push(`${opts.indent}// action body...`);
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function extractFieldName(path) {
+  const parts = parsePath(path);
+  return parts[parts.length - 1] ?? "";
+}
+function extractTypeName(path) {
+  const parts = parsePath(path);
+  if (parts.length >= 2) {
+    return parts[0];
+  }
+  return void 0;
+}
+
+// src/renderer/fragment.ts
+var DEFAULT_FRAGMENT_OPTIONS = {
+  indent: "  ",
+  includeComments: true,
+  commentPrefix: "// ",
+  includeMetadata: true,
+  includeEvidence: false,
+  includeConfidence: true,
+  includeFragmentId: false
+};
+function renderFragment(fragment, options) {
+  const opts = { ...DEFAULT_FRAGMENT_OPTIONS, ...options };
+  const lines = [];
+  if (opts.includeMetadata) {
+    if (opts.includeFragmentId) {
+      lines.push(`${opts.commentPrefix}Fragment: ${fragment.fragmentId}`);
+    }
+    if (opts.includeConfidence) {
+      const confidencePercent = (fragment.confidence * 100).toFixed(0);
+      lines.push(`${opts.commentPrefix}Confidence: ${confidencePercent}%`);
+    }
+    if (opts.includeEvidence && fragment.evidence.length > 0) {
+      lines.push(`${opts.commentPrefix}Evidence:`);
+      for (const evidence of fragment.evidence) {
+        lines.push(`${opts.commentPrefix}  - ${evidence}`);
+      }
+    }
+  }
+  const opStr = renderPatchOp(fragment.op, {
+    indent: opts.indent,
+    includeComments: opts.includeComments,
+    commentPrefix: opts.commentPrefix
+  });
+  lines.push(opStr);
+  return lines.join("\n");
+}
+function renderFragments(fragments, options) {
+  const opts = { ...DEFAULT_FRAGMENT_OPTIONS, ...options };
+  const renderedFragments = fragments.map(
+    (fragment) => renderFragment(fragment, opts)
+  );
+  return renderedFragments.join("\n\n");
+}
+function renderFragmentsByKind(fragments, options) {
+  const opts = { ...DEFAULT_FRAGMENT_OPTIONS, ...options };
+  const grouped = {};
+  for (const fragment of fragments) {
+    const kind = fragment.op.kind;
+    if (!grouped[kind]) {
+      grouped[kind] = [];
+    }
+    grouped[kind].push(fragment);
+  }
+  const result = {};
+  for (const [kind, kindFragments] of Object.entries(grouped)) {
+    result[kind] = renderFragments(kindFragments, opts);
+  }
+  return result;
+}
+function renderAsDomain(domainName, fragments, options) {
+  const opts = { ...DEFAULT_FRAGMENT_OPTIONS, ...options };
+  const indent = opts.indent ?? "  ";
+  const types = [];
+  const fields = [];
+  const defaults = [];
+  const computed = [];
+  const constraints = [];
+  const actions = [];
+  for (const fragment of fragments) {
+    switch (fragment.op.kind) {
+      case "addType":
+        types.push(fragment);
+        break;
+      case "addField":
+      case "setFieldType":
+        fields.push(fragment);
+        break;
+      case "setDefaultValue":
+        defaults.push(fragment);
+        break;
+      case "addComputed":
+        computed.push(fragment);
+        break;
+      case "addConstraint":
+        constraints.push(fragment);
+        break;
+      case "addActionAvailable":
+        actions.push(fragment);
+        break;
+    }
+  }
+  const lines = [];
+  lines.push(`domain ${domainName} {`);
+  if (fields.length > 0 || defaults.length > 0) {
+    lines.push(`${indent}state {`);
+    for (const fragment of [...fields, ...defaults]) {
+      const rendered = renderPatchOp(fragment.op, { indent: indent + indent, includeComments: false });
+      lines.push(`${indent}${indent}${rendered}`);
+    }
+    lines.push(`${indent}}`);
+    lines.push("");
+  }
+  for (const fragment of types) {
+    const rendered = renderPatchOp(fragment.op, { indent, includeComments: false });
+    const indented = rendered.split("\n").map((line) => `${indent}${line}`).join("\n");
+    lines.push(indented);
+    lines.push("");
+  }
+  for (const fragment of computed) {
+    const rendered = renderPatchOp(fragment.op, { indent, includeComments: false });
+    lines.push(`${indent}${rendered}`);
+  }
+  if (computed.length > 0) lines.push("");
+  for (const fragment of constraints) {
+    const rendered = renderPatchOp(fragment.op, { indent, includeComments: true });
+    lines.push(`${indent}${rendered}`);
+  }
+  if (constraints.length > 0) lines.push("");
+  for (const fragment of actions) {
+    const rendered = renderPatchOp(fragment.op, { indent, includeComments: false });
+    const indented = rendered.split("\n").map((line) => `${indent}${line}`).join("\n");
+    lines.push(indented);
+    lines.push("");
+  }
+  lines.push("}");
+  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) {
+  return {
+    snapshot: options.snapshot ?? { data: {}, computed: {} },
+    meta: options.meta,
+    input: options.input ?? {},
+    item: options.item
+  };
+}
+function applyPatchToWorkingSnapshot(snapshot, path, value) {
+  const newData = structuredClone(snapshot.data);
+  setValueAtPath(newData, path, value);
+  return {
+    data: newData,
+    computed: snapshot.computed
+  };
+}
+function setValueAtPath(obj, path, value) {
+  const parts = parsePath2(path);
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  current[lastPart] = value;
+}
+
+// src/evaluation/evaluate-expr.ts
+import { parsePath as parsePath3 } from "@manifesto-ai/core";
+function evaluateExpr(expr, ctx) {
+  try {
+    return evaluateNode(expr, ctx);
+  } catch {
+    return null;
+  }
+}
+function evaluateNode(expr, ctx) {
+  switch (expr.kind) {
+    // Literals
+    case "lit":
+      return expr.value;
+    case "get":
+      return resolvePath(expr.path, ctx);
+    // Comparison
+    case "eq":
+      return evaluateEq(expr.left, expr.right, ctx);
+    case "neq":
+      return evaluateNeq(expr.left, expr.right, ctx);
+    case "gt":
+      return evaluateComparison(expr.left, expr.right, ctx, (a, b) => a > b);
+    case "gte":
+      return evaluateComparison(expr.left, expr.right, ctx, (a, b) => a >= b);
+    case "lt":
+      return evaluateComparison(expr.left, expr.right, ctx, (a, b) => a < b);
+    case "lte":
+      return evaluateComparison(expr.left, expr.right, ctx, (a, b) => a <= b);
+    // Logical
+    case "and":
+      return evaluateAnd(expr.args, ctx);
+    case "or":
+      return evaluateOr(expr.args, ctx);
+    case "not":
+      return evaluateNot(expr.arg, ctx);
+    // Conditional
+    case "if":
+      return evaluateIf(expr.cond, expr.then, expr.else, ctx);
+    // Arithmetic
+    case "add":
+      return evaluateArithmetic(expr.left, expr.right, ctx, (a, b) => a + b);
+    case "sub":
+      return evaluateArithmetic(expr.left, expr.right, ctx, (a, b) => a - b);
+    case "mul":
+      return evaluateArithmetic(expr.left, expr.right, ctx, (a, b) => a * b);
+    case "div":
+      return evaluateDiv(expr.left, expr.right, ctx);
+    case "mod":
+      return evaluateMod(expr.left, expr.right, ctx);
+    // String
+    case "concat":
+      return evaluateConcat(expr.args, ctx);
+    case "substring":
+      return evaluateSubstring(expr.str, expr.start, expr.end, ctx);
+    case "trim":
+      return evaluateTrim(expr.str, ctx);
+    // Collection
+    case "len":
+      return evaluateLen(expr.arg, ctx);
+    case "at":
+      return evaluateAt(expr.array, expr.index, ctx);
+    case "first":
+      return evaluateFirst(expr.array, ctx);
+    case "last":
+      return evaluateLast(expr.array, ctx);
+    case "slice":
+      return evaluateSlice(expr.array, expr.start, expr.end, ctx);
+    case "includes":
+      return evaluateIncludes(expr.array, expr.item, ctx);
+    case "filter":
+      return evaluateFilter(expr.array, expr.predicate, ctx);
+    case "map":
+      return evaluateMap(expr.array, expr.mapper, ctx);
+    case "find":
+      return evaluateFind(expr.array, expr.predicate, ctx);
+    case "every":
+      return evaluateEvery(expr.array, expr.predicate, ctx);
+    case "some":
+      return evaluateSome(expr.array, expr.predicate, ctx);
+    case "append":
+      return evaluateAppend(expr.array, expr.items, ctx);
+    // Object
+    case "object":
+      return evaluateObject(expr.fields, ctx);
+    case "field":
+      return evaluateFieldAccess(expr.object, expr.property, ctx);
+    case "keys":
+      return evaluateKeys(expr.obj, ctx);
+    case "values":
+      return evaluateValues(expr.obj, ctx);
+    case "entries":
+      return evaluateEntries(expr.obj, ctx);
+    case "merge":
+      return evaluateMerge(expr.objects, ctx);
+    // Type
+    case "typeof":
+      return evaluateTypeof(expr.arg, ctx);
+    case "isNull":
+      return evaluateIsNull(expr.arg, ctx);
+    case "coalesce":
+      return evaluateCoalesce(expr.args, ctx);
+    default:
+      return null;
+  }
+}
+function resolvePath(path, ctx) {
+  const parts = parsePath3(path);
+  if (parts[0] === "meta") {
+    return getValueAtPath(ctx.meta, parts.slice(1));
+  }
+  if (parts[0] === "input") {
+    return getValueAtPath(ctx.input, parts.slice(1));
+  }
+  if (parts[0] === "$item") {
+    if (ctx.item === void 0) {
+      return null;
+    }
+    if (parts.length === 1) {
+      return ctx.item;
+    }
+    return getValueAtPath(ctx.item, parts.slice(1));
+  }
+  if (path in ctx.snapshot.computed) {
+    return ctx.snapshot.computed[path];
+  }
+  return getValueAtPath(ctx.snapshot.data, parts);
+}
+function getValueAtPath(obj, parts) {
+  if (parts.length === 0) {
+    return obj;
+  }
+  if (obj === null || obj === void 0) {
+    return null;
+  }
+  if (typeof obj !== "object") {
+    return null;
+  }
+  const [head, ...rest] = parts;
+  const next = obj[head];
+  if (rest.length === 0) {
+    return next === void 0 ? null : next;
+  }
+  return getValueAtPath(next, rest);
+}
+function evaluateEq(left, right, ctx) {
+  const l = evaluateNode(left, ctx);
+  const r = evaluateNode(right, ctx);
+  return deepEqual(l, r);
+}
+function evaluateNeq(left, right, ctx) {
+  const result = evaluateEq(left, right, ctx);
+  if (result === null) return null;
+  return !result;
+}
+function evaluateComparison(left, right, ctx, compare) {
+  const l = evaluateNode(left, ctx);
+  const r = evaluateNode(right, ctx);
+  if (typeof l !== "number" || typeof r !== "number") {
+    return null;
+  }
+  return compare(l, r);
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, i) => deepEqual(item, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every(
+      (key) => Object.prototype.hasOwnProperty.call(b, key) && deepEqual(
+        a[key],
+        b[key]
+      )
+    );
+  }
+  return false;
+}
+function evaluateAnd(args, ctx) {
+  for (const arg of args) {
+    const result = evaluateNode(arg, ctx);
+    if (result !== true) {
+      return result === false ? false : null;
+    }
+  }
+  return true;
+}
+function evaluateOr(args, ctx) {
+  for (const arg of args) {
+    const result = evaluateNode(arg, ctx);
+    if (result === true) {
+      return true;
+    }
+    if (result !== false) {
+      return null;
+    }
+  }
+  return false;
+}
+function evaluateNot(arg, ctx) {
+  const result = evaluateNode(arg, ctx);
+  if (typeof result !== "boolean") {
+    return null;
+  }
+  return !result;
+}
+function evaluateIf(cond, thenExpr, elseExpr, ctx) {
+  const condResult = evaluateNode(cond, ctx);
+  if (condResult === true) {
+    return evaluateNode(thenExpr, ctx);
+  }
+  if (condResult === false) {
+    return evaluateNode(elseExpr, ctx);
+  }
+  return null;
+}
+function evaluateArithmetic(left, right, ctx, op) {
+  const l = evaluateNode(left, ctx);
+  const r = evaluateNode(right, ctx);
+  if (typeof l !== "number" || typeof r !== "number") {
+    return null;
+  }
+  const result = op(l, r);
+  if (!Number.isFinite(result)) {
+    return null;
+  }
+  return result;
+}
+function evaluateDiv(left, right, ctx) {
+  const l = evaluateNode(left, ctx);
+  const r = evaluateNode(right, ctx);
+  if (typeof l !== "number" || typeof r !== "number") {
+    return null;
+  }
+  if (r === 0) {
+    return null;
+  }
+  return l / r;
+}
+function evaluateMod(left, right, ctx) {
+  const l = evaluateNode(left, ctx);
+  const r = evaluateNode(right, ctx);
+  if (typeof l !== "number" || typeof r !== "number") {
+    return null;
+  }
+  if (r === 0) {
+    return null;
+  }
+  return l % r;
+}
+function evaluateConcat(args, ctx) {
+  const values = [];
+  for (const arg of args) {
+    const val = evaluateNode(arg, ctx);
+    if (typeof val !== "string") {
+      return null;
+    }
+    values.push(val);
+  }
+  return values.join("");
+}
+function evaluateSubstring(str, start, end, ctx) {
+  const s = evaluateNode(str, ctx);
+  const startIdx = evaluateNode(start, ctx);
+  if (typeof s !== "string" || typeof startIdx !== "number") {
+    return null;
+  }
+  if (end === void 0) {
+    return s.substring(startIdx);
+  }
+  const endIdx = evaluateNode(end, ctx);
+  if (typeof endIdx !== "number") {
+    return null;
+  }
+  return s.substring(startIdx, endIdx);
+}
+function evaluateTrim(str, ctx) {
+  const s = evaluateNode(str, ctx);
+  if (typeof s !== "string") {
+    return null;
+  }
+  return s.trim();
+}
+function evaluateLen(arg, ctx) {
+  const val = evaluateNode(arg, ctx);
+  if (Array.isArray(val)) {
+    return val.length;
+  }
+  if (typeof val === "string") {
+    return val.length;
+  }
+  if (val !== null && typeof val === "object") {
+    return Object.keys(val).length;
+  }
+  return null;
+}
+function evaluateAt(array, index, ctx) {
+  const base = evaluateNode(array, ctx);
+  const key = evaluateNode(index, ctx);
+  if (Array.isArray(base) && typeof key === "number") {
+    if (key < 0 || key >= base.length) {
+      return null;
+    }
+    return base[key];
+  }
+  if (typeof base === "object" && base !== null && !Array.isArray(base) && typeof key === "string") {
+    return base[key] ?? null;
+  }
+  return null;
+}
+function evaluateFirst(array, ctx) {
+  const arr = evaluateNode(array, ctx);
+  if (!Array.isArray(arr) || arr.length === 0) {
+    return null;
+  }
+  return arr[0];
+}
+function evaluateLast(array, ctx) {
+  const arr = evaluateNode(array, ctx);
+  if (!Array.isArray(arr) || arr.length === 0) {
+    return null;
+  }
+  return arr[arr.length - 1];
+}
+function evaluateSlice(array, start, end, ctx) {
+  const arr = evaluateNode(array, ctx);
+  const startIdx = evaluateNode(start, ctx);
+  if (!Array.isArray(arr) || typeof startIdx !== "number") {
+    return null;
+  }
+  if (end === void 0) {
+    return arr.slice(startIdx);
+  }
+  const endIdx = evaluateNode(end, ctx);
+  if (typeof endIdx !== "number") {
+    return null;
+  }
+  return arr.slice(startIdx, endIdx);
+}
+function evaluateIncludes(array, item, ctx) {
+  const arr = evaluateNode(array, ctx);
+  const val = evaluateNode(item, ctx);
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+  return arr.some((el) => deepEqual(el, val));
+}
+function evaluateFilter(array, predicate, ctx) {
+  const arr = evaluateNode(array, ctx);
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+  const result = [];
+  for (const item of arr) {
+    const itemCtx = { ...ctx, item };
+    const keep = evaluateNode(predicate, itemCtx);
+    if (keep === true) {
+      result.push(item);
+    } else if (keep !== false) {
+      return null;
+    }
+  }
+  return result;
+}
+function evaluateMap(array, mapper, ctx) {
+  const arr = evaluateNode(array, ctx);
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+  const result = [];
+  for (const item of arr) {
+    const itemCtx = { ...ctx, item };
+    const mapped = evaluateNode(mapper, itemCtx);
+    result.push(mapped);
+  }
+  return result;
+}
+function evaluateFind(array, predicate, ctx) {
+  const arr = evaluateNode(array, ctx);
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+  for (const item of arr) {
+    const itemCtx = { ...ctx, item };
+    const match = evaluateNode(predicate, itemCtx);
+    if (match === true) {
+      return item;
+    }
+    if (match !== false) {
+      return null;
+    }
+  }
+  return null;
+}
+function evaluateEvery(array, predicate, ctx) {
+  const arr = evaluateNode(array, ctx);
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+  for (const item of arr) {
+    const itemCtx = { ...ctx, item };
+    const result = evaluateNode(predicate, itemCtx);
+    if (result === false) {
+      return false;
+    }
+    if (result !== true) {
+      return null;
+    }
+  }
+  return true;
+}
+function evaluateSome(array, predicate, ctx) {
+  const arr = evaluateNode(array, ctx);
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+  for (const item of arr) {
+    const itemCtx = { ...ctx, item };
+    const result = evaluateNode(predicate, itemCtx);
+    if (result === true) {
+      return true;
+    }
+    if (result !== false) {
+      return null;
+    }
+  }
+  return false;
+}
+function evaluateAppend(array, items, ctx) {
+  const arr = evaluateNode(array, ctx);
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+  const itemValues = items.map((item) => evaluateNode(item, ctx));
+  return [...arr, ...itemValues];
+}
+function evaluateObject(fields, ctx) {
+  const result = {};
+  for (const [key, value] of Object.entries(fields)) {
+    result[key] = evaluateNode(value, ctx);
+  }
+  return result;
+}
+function evaluateFieldAccess(objectExpr, property, ctx) {
+  const obj = evaluateNode(objectExpr, ctx);
+  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+    return null;
+  }
+  return obj[property] ?? null;
+}
+function evaluateKeys(obj, ctx) {
+  const o = evaluateNode(obj, ctx);
+  if (o === null || typeof o !== "object" || Array.isArray(o)) {
+    return null;
+  }
+  return Object.keys(o);
+}
+function evaluateValues(obj, ctx) {
+  const o = evaluateNode(obj, ctx);
+  if (o === null || typeof o !== "object" || Array.isArray(o)) {
+    return null;
+  }
+  return Object.values(o);
+}
+function evaluateEntries(obj, ctx) {
+  const o = evaluateNode(obj, ctx);
+  if (o === null || typeof o !== "object" || Array.isArray(o)) {
+    return null;
+  }
+  return Object.entries(o);
+}
+function evaluateMerge(objects, ctx) {
+  const result = {};
+  for (const objExpr of objects) {
+    const o = evaluateNode(objExpr, ctx);
+    if (o === null || typeof o !== "object" || Array.isArray(o)) {
+      return null;
+    }
+    Object.assign(result, o);
+  }
+  return result;
+}
+function evaluateTypeof(arg, ctx) {
+  const val = evaluateNode(arg, ctx);
+  if (val === null) return "null";
+  if (Array.isArray(val)) return "array";
+  return typeof val;
+}
+function evaluateIsNull(arg, ctx) {
+  const val = evaluateNode(arg, ctx);
+  return val === null;
+}
+function evaluateCoalesce(args, ctx) {
+  for (const arg of args) {
+    const val = evaluateNode(arg, ctx);
+    if (val !== null && val !== void 0) {
+      return val;
+    }
+  }
+  return null;
+}
+
+// src/evaluation/evaluate-patch.ts
+function evaluateConditionalPatchOps(ops, ctx) {
+  const patches = [];
+  const skipped = [];
+  let workingSnapshot = ctx.snapshot;
+  for (const op of ops) {
+    const evalCtx = {
+      ...ctx,
+      snapshot: workingSnapshot
+    };
+    if (op.condition !== void 0) {
+      const conditionResult = evaluateExpr(op.condition, evalCtx);
+      if (conditionResult !== true) {
+        const reason = conditionResult === false ? "false" : conditionResult === null ? "null" : "non-boolean";
+        skipped.push({ fragmentId: op.fragmentId, reason });
+        continue;
+      }
+    }
+    const evaluated = {
+      fragmentId: op.fragmentId,
+      op: op.op,
+      confidence: op.confidence,
+      conditionEvaluated: op.condition !== void 0
+    };
+    patches.push(evaluated);
+    workingSnapshot = updateWorkingSnapshot(workingSnapshot, op.op, evalCtx);
+  }
+  return {
+    patches,
+    skipped,
+    finalSnapshot: workingSnapshot
+  };
+}
+function evaluatePatches(ops, ctx) {
+  return ops.filter((op) => {
+    if (op.condition === void 0) {
+      return true;
+    }
+    return evaluateExpr(op.condition, ctx) === true;
+  }).map((op) => ({
+    fragmentId: op.fragmentId,
+    op: op.op,
+    confidence: op.confidence,
+    conditionEvaluated: op.condition !== void 0
+  }));
+}
+function updateWorkingSnapshot(snapshot, op, _ctx) {
+  switch (op.kind) {
+    case "setDefaultValue":
+      return applyPatchToWorkingSnapshot(snapshot, op.path, op.value);
+    case "addType":
+    case "addField":
+    case "setFieldType":
+    case "addConstraint":
+    case "addComputed":
+    case "addActionAvailable":
+      return snapshot;
+  }
+}
+function evaluatePatchExpressions(op, ctx) {
+  switch (op.kind) {
+    case "addType":
+    case "addField":
+    case "setFieldType":
+    case "setDefaultValue":
+      return op;
+    case "addConstraint":
+      return {
+        ...op
+        // Keep rule as expression - it's evaluated at runtime by Core
+      };
+    case "addComputed":
+      return {
+        ...op
+        // Keep expr as expression - it's evaluated at runtime by Core
+      };
+    case "addActionAvailable":
+      return {
+        ...op
+        // Keep expr as expression - it's evaluated at runtime by Core
+      };
+  }
+}
+function evaluateCondition(condition, ctx) {
+  if (condition === void 0) {
+    return true;
+  }
+  const result = evaluateExpr(condition, ctx);
+  return result === true;
+}
+function classifyCondition(condition, ctx) {
+  if (condition === void 0) {
+    return { passes: true, reason: "no-condition" };
+  }
+  const result = evaluateExpr(condition, ctx);
+  if (result === true) {
+    return { passes: true, reason: "true" };
+  }
+  if (result === false) {
+    return { passes: false, reason: "false" };
+  }
+  if (result === null) {
+    return { passes: false, reason: "null" };
+  }
+  return { passes: false, reason: "non-boolean" };
+}
+
+// src/evaluation/evaluate-runtime-patch.ts
+import { mergeAtPatchPath, patchPathToDisplayString, setByPatchPath, unsetByPatchPath } from "@manifesto-ai/core";
+var UNSAFE_PROP_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function evaluateRuntimePatches(ops, ctx) {
+  const result = evaluateRuntimePatchesWithTrace(ops, ctx);
+  return result.patches;
+}
+function evaluateRuntimePatchesWithTrace(ops, ctx) {
+  const patches = [];
+  const skipped = [];
+  const warnings = [];
+  let workingSnapshot = ctx.snapshot;
+  const guardScopeStack = [];
+  for (let i = 0; i < ops.length; i++) {
+    const op = ops[i];
+    const isScopedSet = op.op === "set" && isScopedMarkerPath(op.path);
+    const isInScope = guardScopeStack.length > 0;
+    const activeSnapshot = isScopedSet || !isInScope ? workingSnapshot : guardScopeStack[guardScopeStack.length - 1].snapshot;
+    const evalCtx = {
+      ...ctx,
+      snapshot: activeSnapshot
+    };
+    if (op.condition !== void 0) {
+      const conditionResult = evaluateExpr(op.condition, evalCtx);
+      if (conditionResult !== true) {
+        const reason = conditionResult === false ? "false" : conditionResult === null ? "null" : "non-boolean";
+        skipped.push({
+          index: i,
+          path: irPathToDisplayString(op.path),
+          reason
+        });
+        continue;
+      }
+    }
+    const resolvedPath = resolveIRPath(op.path, evalCtx);
+    if (!resolvedPath.ok) {
+      skipped.push({
+        index: i,
+        path: irPathToDisplayString(op.path),
+        reason: "invalid-path"
+      });
+      warnings.push(`Skipped runtime patch at index ${i}: ${resolvedPath.warning}`);
+      continue;
+    }
+    const concretePath = resolvedPath.path;
+    const concreteValue = op.value ? evaluateExpr(op.value, evalCtx) : void 0;
+    const patch = buildConcretePatch(op.op, concretePath, concreteValue);
+    if (patch === null) {
+      continue;
+    }
+    if (op.op === "unset" && isScopedMarkerPath(op.path) && (!isInScope || !isPatchPathEqual(
+      guardScopeStack[guardScopeStack.length - 1].markerPath,
+      concretePath
+    ))) {
+      continue;
+    }
+    patches.push(patch);
+    workingSnapshot = applyConcretePatchToWorkingSnapshot(workingSnapshot, patch);
+    if (op.op === "set" && isScopedMarkerPath(op.path)) {
+      guardScopeStack.push({
+        markerPath: concretePath,
+        snapshot: workingSnapshot
+      });
+      continue;
+    }
+    if (op.op === "unset" && isScopedMarkerPath(op.path) && guardScopeStack.length > 0 && isPatchPathEqual(
+      guardScopeStack[guardScopeStack.length - 1].markerPath,
+      concretePath
+    )) {
+      guardScopeStack.pop();
+    }
+  }
+  return {
+    patches,
+    skipped,
+    warnings,
+    finalSnapshot: workingSnapshot
+  };
+}
+function buildConcretePatch(op, path, value) {
+  switch (op) {
+    case "set":
+      return { op: "set", path, value };
+    case "unset":
+      return { op: "unset", path };
+    case "merge":
+      if (isRecord(value)) {
+        return { op: "merge", path, value };
+      }
+      return { op: "set", path, value: null };
+  }
+}
+function applyConcretePatchToWorkingSnapshot(snapshot, patch) {
+  const baseData = snapshot.data;
+  const nextData = (() => {
+    switch (patch.op) {
+      case "set":
+        return setByPatchPath(baseData, patch.path, patch.value);
+      case "unset":
+        return unsetByPatchPath(baseData, patch.path);
+      case "merge":
+        return mergeAtPatchPath(baseData, patch.path, patch.value);
+    }
+  })();
+  return {
+    data: nextData,
+    computed: snapshot.computed
+  };
+}
+function resolveIRPath(path, ctx) {
+  if (path.length === 0) {
+    return { ok: false, warning: "path is empty" };
+  }
+  const resolved = [];
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (segment.kind === "prop") {
+      if (!isValidPropSegment(segment.name)) {
+        return { ok: false, warning: `invalid prop segment '${segment.name}'` };
+      }
+      resolved.push({ kind: "prop", name: segment.name });
+      continue;
+    }
+    const value = evaluateExpr(segment.expr, ctx);
+    const concrete = toConcreteSegment(value);
+    if (concrete === null) {
+      return {
+        ok: false,
+        warning: `expr segment at index ${i} resolved to invalid value`
+      };
+    }
+    resolved.push(concrete);
+  }
+  return { ok: true, path: resolved };
+}
+function toConcreteSegment(value) {
+  if (typeof value === "number" && Number.isInteger(value) && Number.isFinite(value) && value >= 0) {
+    return { kind: "index", index: value };
+  }
+  if (typeof value === "string" && value.length > 0 && isValidPropSegment(value)) {
+    return { kind: "prop", name: value };
+  }
+  return null;
+}
+function isValidPropSegment(name) {
+  return name.length > 0 && !UNSAFE_PROP_SEGMENTS.has(name);
+}
+function isScopedMarkerPath(path) {
+  return hasPropPrefix(path, ["$mel", "__whenGuards"]) || hasPropPrefix(path, ["$mel", "__onceScopeGuards"]);
+}
+function hasPropPrefix(path, prefix) {
+  if (path.length < prefix.length) {
+    return false;
+  }
+  for (let i = 0; i < prefix.length; i++) {
+    const segment = path[i];
+    if (segment.kind !== "prop" || segment.name !== prefix[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function isPatchPathEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    const left = a[i];
+    const right = b[i];
+    if (left.kind !== right.kind) {
+      return false;
+    }
+    if (left.kind === "prop" && right.kind === "prop" && left.name !== right.name) {
+      return false;
+    }
+    if (left.kind === "index" && right.kind === "index" && left.index !== right.index) {
+      return false;
+    }
+  }
+  return true;
+}
+function irPathToDisplayString(path) {
+  const concretePrefix = [];
+  for (const segment of path) {
+    if (segment.kind === "prop") {
+      concretePrefix.push({ kind: "prop", name: segment.name });
+      continue;
+    }
+    if (concretePrefix.length === 0) {
+      return "[expr]";
+    }
+    return `${patchPathToDisplayString(concretePrefix)}.[expr]`;
+  }
+  if (concretePrefix.length === 0) {
+    return "";
+  }
+  return patchPathToDisplayString(concretePrefix);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/index.ts
+function compile(source, options = {}) {
+  const trace = [];
+  const lexStart = performance.now();
+  const lexResult = tokenize(source);
+  trace.push({ phase: "lex", durationMs: performance.now() - lexStart, details: { tokenCount: lexResult.tokens.length } });
+  if (hasErrors(lexResult.diagnostics)) {
+    return {
+      schema: null,
+      trace,
+      warnings: lexResult.diagnostics.filter((d) => d.severity === "warning"),
+      errors: lexResult.diagnostics.filter((d) => d.severity === "error"),
+      success: false
+    };
+  }
+  const parseStart = performance.now();
+  const parseResult = parse(lexResult.tokens);
+  const parseErrors = parseResult.diagnostics;
+  trace.push({ phase: "parse", durationMs: performance.now() - parseStart });
+  if (hasErrors(parseErrors)) {
+    return {
+      schema: null,
+      trace,
+      warnings: parseErrors.filter((d) => d.severity === "warning"),
+      errors: parseErrors.filter((d) => d.severity === "error"),
+      success: false
+    };
+  }
+  const diagnostics = [];
+  if (!options.skipSemanticAnalysis && parseResult.program) {
+    const scopeResult = analyzeScope(parseResult.program);
+    const validateResult = validateSemantics(parseResult.program);
+    diagnostics.push(...scopeResult.diagnostics, ...validateResult.diagnostics);
+  }
+  const generateStart = performance.now();
+  const genResult = generate(parseResult.program);
+  diagnostics.push(...genResult.diagnostics);
+  trace.push({ phase: "generate", durationMs: performance.now() - generateStart });
+  if (options.skipSemanticAnalysis) {
+    diagnostics.push(...parseResult.diagnostics);
+  }
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  if (genResult.schema === null || errors.length > 0) {
+    return {
+      schema: null,
+      trace,
+      warnings: diagnostics.filter((d) => d.severity === "warning"),
+      errors,
+      success: false
+    };
+  }
+  let schema = genResult.schema;
+  if (options.lowerSystemValues) {
+    const lowerStart = performance.now();
+    schema = lowerSystemValues(schema);
+    trace.push({ phase: "lower", durationMs: performance.now() - lowerStart });
+  }
+  const warnings = diagnostics.filter((d) => d.severity === "warning");
+  return {
+    schema,
+    trace,
+    warnings,
+    errors: diagnostics.filter((d) => d.severity === "error"),
+    success: errors.length === 0
+  };
+}
+function parseSource(source) {
+  const lexResult = tokenize(source);
+  if (hasErrors(lexResult.diagnostics)) {
+    return { program: null, diagnostics: lexResult.diagnostics };
+  }
+  return parse(lexResult.tokens);
+}
+function check(source) {
+  const result = compile(source);
+  return result.errors;
+}
+export {
+  DEFAULT_ACTION_CONTEXT,
+  DEFAULT_PATCH_CONTEXT,
+  DEFAULT_SCHEMA_CONTEXT,
+  DIAGNOSTIC_CODES,
+  EFFECT_ARGS_CONTEXT,
+  KEYWORDS,
+  Lexer,
+  LoweringError,
+  Parser,
+  Precedence,
+  RESERVED_KEYWORDS,
+  Scope,
+  ScopeAnalyzer,
+  SemanticValidator,
+  analyzeScope,
+  applyPatchToWorkingSnapshot,
+  check,
+  classifyCondition,
+  compile,
+  compileMelDomain,
+  compileMelPatch,
+  createError,
+  createEvaluationContext,
+  createInfo,
+  createLocation,
+  createPointLocation,
+  createPosition,
+  createToken,
+  createWarning,
+  evaluateCondition,
+  evaluateConditionalPatchOps,
+  evaluateExpr,
+  evaluatePatchExpressions,
+  evaluatePatches,
+  evaluateRuntimePatches,
+  evaluateRuntimePatchesWithTrace,
+  extractTypeName,
+  filterBySeverity,
+  formatDiagnostic,
+  formatDiagnosticCode,
+  formatDiagnostics,
+  generate,
+  getBinaryPrecedence,
+  getDiagnosticInfo,
+  getKeywordKind,
+  hasErrors,
+  invalidKindForContext,
+  invalidShape,
+  invalidSysPath,
+  isBinaryOp,
+  isError,
+  isExprNode,
+  isKeyword,
+  isReserved,
+  isRightAssociative,
+  isStmtNode,
+  isUnaryOp,
+  lowerExprNode,
+  lowerPatchFragments,
+  lowerRuntimePatch,
+  lowerRuntimePatches,
+  lowerSystemValues,
+  mergeLocations,
+  normalizeExpr,
+  normalizeFunctionCall,
+  parse,
+  parseSource,
+  renderAsDomain,
+  renderExprNode,
+  renderFragment,
+  renderFragments,
+  renderFragmentsByKind,
+  renderPatchOp,
+  renderTypeExpr,
+  renderTypeField,
+  renderValue,
+  tokenToBinaryOp,
+  tokenize,
+  unknownCallFn,
+  unknownNodeKind,
+  unsupportedBase,
+  validateSemantics
+};
 //# sourceMappingURL=index.js.map