@manifesto-ai/compiler 1.8.0 → 1.8.2

package/dist/{chunk-MKLDAZ2Z.js → chunk-4JJQCFJH.js}

@@ -2002,16 +2002,16 @@ function inferExprType(expr, env, symbols) {
         location: expr.location
       };
     case "arrayLiteral": {
-      if (expr.elements.length === 0) {
-        return null;
-      }
-      const firstElementType = inferExprType(expr.elements[0], env, symbols);
-      if (!firstElementType) {
+      const elementType = joinTypeCandidates(
+        expr.elements.map((element) => inferExprType(element, env, symbols)),
+        expr.location
+      );
+      if (!elementType) {
         return null;
       }
       return {
         kind: "arrayType",
-        elementType: firstElementType,
+        elementType,
         location: expr.location
       };
     }
@@ -2030,8 +2030,9 @@ function inferExprType(expr, env, symbols) {
     case "functionCall":
       return inferFunctionCallType(expr, env, symbols);
     case "systemIdent":
-    case "iterationVar":
       return null;
+    case "iterationVar":
+      return env.get("$item") ?? null;
   }
 }
 function classifyComparableExpr(expr, env, symbols) {
@@ -2265,6 +2266,29 @@ function inferFunctionCallType(expr, env, symbols) {
     }
     return joinTypeCandidates([elementType, simpleType("null", expr.location)], expr.location);
   }
+  if (expr.name === "filter" && expr.args.length >= 1) {
+    return inferExprType(expr.args[0], env, symbols);
+  }
+  if (expr.name === "map" && expr.args.length >= 2) {
+    const arrayType = inferExprType(expr.args[0], env, symbols);
+    const elementType = getArrayElementType(arrayType, symbols);
+    if (!elementType) {
+      return null;
+    }
+    const mapperType = inferExprType(
+      expr.args[1],
+      extendCollectionEnv(env, elementType),
+      symbols
+    );
+    if (!mapperType) {
+      return null;
+    }
+    return {
+      kind: "arrayType",
+      elementType: mapperType,
+      location: expr.location
+    };
+  }
   if ((expr.name === "first" || expr.name === "last") && expr.args.length >= 1) {
     return getArrayElementType(inferExprType(expr.args[0], env, symbols), symbols);
   }
@@ -2299,6 +2323,20 @@ function inferFunctionCallType(expr, env, symbols) {
   if (expr.name === "slice" && expr.args.length >= 1) {
     return inferExprType(expr.args[0], env, symbols);
   }
+  if (expr.name === "split") {
+    return {
+      kind: "arrayType",
+      elementType: simpleType("string", expr.location),
+      location: expr.location
+    };
+  }
+  if (expr.name === "keys") {
+    return {
+      kind: "arrayType",
+      elementType: simpleType("string", expr.location),
+      location: expr.location
+    };
+  }
   return null;
 }
 function joinComparableClasses(classes) {
@@ -2360,6 +2398,11 @@ function getStaticPropertyName(expr) {
   }
   return null;
 }
+function extendCollectionEnv(env, itemType) {
+  const next = new Map(env);
+  next.set("$item", itemType);
+  return next;
+}
 
 // src/analyzer/entity-primitives.ts
 var ENTITY_LOOKUP_FNS = /* @__PURE__ */ new Set(["findById", "existsById"]);
@@ -2680,6 +2723,288 @@ function createContext() {
   };
 }
 var STOP_WAITING_REASON_PATTERN = /\b(await(?:ing)?|wait(?:ing)?|pending)\b/i;
+function simpleTypeNode(name, location) {
+  return {
+    kind: "simpleType",
+    name,
+    location
+  };
+}
+function isAssignableType(sourceType, targetType, symbols) {
+  const resolvedSource = resolveType(sourceType, symbols);
+  const resolvedTarget = resolveType(targetType, symbols);
+  if (!resolvedSource || !resolvedTarget) {
+    return null;
+  }
+  if (resolvedTarget.kind === "unionType") {
+    const sourceMembers = resolvedSource.kind === "unionType" ? resolvedSource.types : [resolvedSource];
+    let sawUnknown = false;
+    for (const member of sourceMembers) {
+      const outcomes = resolvedTarget.types.map(
+        (candidate) => isAssignableType(member, candidate, symbols)
+      );
+      if (outcomes.includes(true)) {
+        continue;
+      }
+      if (outcomes.every((outcome) => outcome === false)) {
+        return false;
+      }
+      sawUnknown = true;
+    }
+    return sawUnknown ? null : true;
+  }
+  if (resolvedSource.kind === "unionType") {
+    let sawUnknown = false;
+    for (const member of resolvedSource.types) {
+      const outcome = isAssignableType(member, resolvedTarget, symbols);
+      if (outcome === false) {
+        return false;
+      }
+      if (outcome === null) {
+        sawUnknown = true;
+      }
+    }
+    return sawUnknown ? null : true;
+  }
+  if (resolvedTarget.kind === "simpleType") {
+    if (resolvedSource.kind === "simpleType") {
+      return resolvedSource.name === resolvedTarget.name;
+    }
+    if (resolvedSource.kind === "literalType") {
+      if (resolvedTarget.name === "null") {
+        return resolvedSource.value === null;
+      }
+      return typeof resolvedSource.value === resolvedTarget.name;
+    }
+  }
+  if (resolvedTarget.kind === "literalType") {
+    if (resolvedSource.kind !== "literalType") {
+      return false;
+    }
+    return resolvedSource.value === resolvedTarget.value;
+  }
+  if (resolvedTarget.kind === "arrayType") {
+    if (resolvedSource.kind !== "arrayType") {
+      return false;
+    }
+    return isAssignableType(resolvedSource.elementType, resolvedTarget.elementType, symbols);
+  }
+  if (resolvedTarget.kind === "objectType") {
+    if (resolvedSource.kind !== "objectType") {
+      return false;
+    }
+    for (const targetField of resolvedTarget.fields) {
+      const sourceField = resolvedSource.fields.find((candidate) => candidate.name === targetField.name);
+      if (!sourceField) {
+        if (targetField.optional) {
+          continue;
+        }
+        return false;
+      }
+      const fieldAssignable = isAssignableType(sourceField.typeExpr, targetField.typeExpr, symbols);
+      if (fieldAssignable !== true) {
+        return fieldAssignable;
+      }
+    }
+    return true;
+  }
+  if (resolvedTarget.kind === "recordType") {
+    if (resolvedSource.kind !== "recordType") {
+      return null;
+    }
+    return isAssignableType(resolvedSource.valueType, resolvedTarget.valueType, symbols);
+  }
+  return null;
+}
+function describeTypeExpr(typeExpr, symbols) {
+  const resolved = resolveType(typeExpr, symbols);
+  if (!resolved) {
+    return "unknown";
+  }
+  switch (resolved.kind) {
+    case "simpleType":
+      return resolved.name;
+    case "literalType":
+      return JSON.stringify(resolved.value);
+    case "arrayType":
+      return `Array<${describeTypeExpr(resolved.elementType, symbols)}>`;
+    case "recordType":
+      return `Record<${describeTypeExpr(resolved.keyType, symbols)}, ${describeTypeExpr(resolved.valueType, symbols)}>`;
+    case "objectType":
+      return `{ ${resolved.fields.map((field) => `${field.name}${field.optional ? "?" : ""}: ${describeTypeExpr(field.typeExpr, symbols)}`).join("; ")} }`;
+    case "unionType":
+      return resolved.types.map((member) => describeTypeExpr(member, symbols)).join(" | ");
+  }
+}
+function collectPrimitiveKinds(typeExpr, symbols) {
+  const resolved = resolveType(typeExpr, symbols);
+  if (!resolved) {
+    return null;
+  }
+  switch (resolved.kind) {
+    case "simpleType":
+      if (resolved.name === "string" || resolved.name === "number" || resolved.name === "boolean" || resolved.name === "null") {
+        return /* @__PURE__ */ new Set([resolved.name]);
+      }
+      return resolved.name === "object" ? "nonprimitive" : null;
+    case "literalType":
+      return /* @__PURE__ */ new Set([
+        resolved.value === null ? "null" : typeof resolved.value
+      ]);
+    case "arrayType":
+    case "recordType":
+    case "objectType":
+      return "nonprimitive";
+    case "unionType": {
+      const kinds = /* @__PURE__ */ new Set();
+      for (const member of resolved.types) {
+        const memberKinds = collectPrimitiveKinds(member, symbols);
+        if (memberKinds === null) {
+          return null;
+        }
+        if (memberKinds === "nonprimitive") {
+          return "nonprimitive";
+        }
+        for (const kind of memberKinds) {
+          kinds.add(kind);
+        }
+      }
+      return kinds;
+    }
+  }
+}
+function areComparableTypesCompatible(leftType, rightType, symbols) {
+  const leftKinds = collectPrimitiveKinds(leftType, symbols);
+  const rightKinds = collectPrimitiveKinds(rightType, symbols);
+  if (leftKinds === null || rightKinds === null) {
+    return null;
+  }
+  if (leftKinds === "nonprimitive" || rightKinds === "nonprimitive") {
+    return false;
+  }
+  if (!(leftKinds instanceof Set) || !(rightKinds instanceof Set)) {
+    return null;
+  }
+  const leftNonNull = [...leftKinds].filter((kind) => kind !== "null");
+  const rightNonNull = [...rightKinds].filter((kind) => kind !== "null");
+  if (leftNonNull.length === 0 || rightNonNull.length === 0) {
+    return true;
+  }
+  return leftNonNull.some((kind) => rightNonNull.includes(kind));
+}
+function stripNullType(typeExpr, symbols) {
+  const resolved = resolveType(typeExpr, symbols);
+  if (!resolved || isNullType(resolved)) {
+    return null;
+  }
+  if (resolved.kind !== "unionType") {
+    return resolved;
+  }
+  const members = resolved.types.filter((member) => !isNullType(member));
+  if (members.length === 0) {
+    return null;
+  }
+  if (members.length === 1) {
+    return members[0];
+  }
+  return {
+    kind: "unionType",
+    types: members,
+    location: resolved.location
+  };
+}
+function areTypesCompatible(leftType, rightType, symbols) {
+  if (!leftType || !rightType) {
+    return null;
+  }
+  const leftToRight = isAssignableType(leftType, rightType, symbols);
+  if (leftToRight === true) {
+    return true;
+  }
+  const rightToLeft = isAssignableType(rightType, leftType, symbols);
+  if (rightToLeft === true) {
+    return true;
+  }
+  const comparable = areComparableTypesCompatible(leftType, rightType, symbols);
+  if (comparable !== null) {
+    return comparable;
+  }
+  if (leftToRight === false && rightToLeft === false) {
+    return false;
+  }
+  return null;
+}
+function classifyArrayOperand(typeExpr, symbols) {
+  const resolved = resolveType(typeExpr, symbols);
+  if (!resolved) {
+    return null;
+  }
+  if (resolved.kind === "unionType") {
+    const outcomes = resolved.types.map((member) => classifyArrayOperand(member, symbols));
+    if (outcomes.every((outcome) => outcome === true)) {
+      return true;
+    }
+    return outcomes.some((outcome) => outcome === false) ? false : null;
+  }
+  return resolved.kind === "arrayType";
+}
+function classifyLenOperand(typeExpr, symbols) {
+  const resolved = resolveType(typeExpr, symbols);
+  if (!resolved) {
+    return null;
+  }
+  if (resolved.kind === "unionType") {
+    const outcomes = resolved.types.map((member) => classifyLenOperand(member, symbols));
+    if (outcomes.every((outcome) => outcome === true)) {
+      return true;
+    }
+    return outcomes.some((outcome) => outcome === false) ? false : null;
+  }
+  if (resolved.kind === "arrayType" || resolved.kind === "recordType" || resolved.kind === "objectType") {
+    return true;
+  }
+  if (resolved.kind === "literalType") {
+    return typeof resolved.value === "string";
+  }
+  if (resolved.kind === "simpleType") {
+    return resolved.name === "string" || resolved.name === "object";
+  }
+  return false;
+}
+function extendCollectionTypeEnv(baseEnv, itemType) {
+  const next = new Map(baseEnv);
+  next.set("$item", itemType);
+  return next;
+}
+function resolvePathType(path, symbols) {
+  const [first, ...rest] = path.segments;
+  if (!first || first.kind !== "propertySegment") {
+    return null;
+  }
+  let current = symbols.stateTypes.get(first.name) ?? null;
+  for (const segment of rest) {
+    if (!current) {
+      return null;
+    }
+    current = segment.kind === "propertySegment" ? getPropertyType(current, segment.name, symbols) : getIndexType(current, symbols);
+  }
+  return current;
+}
+function renderPath(path) {
+  let result = "";
+  for (const [index, segment] of path.segments.entries()) {
+    if (segment.kind === "propertySegment") {
+      result += index === 0 ? segment.name : `.${segment.name}`;
+      continue;
+    }
+    if (segment.index.kind === "literal") {
+      result += `[${JSON.stringify(segment.index.value)}]`;
+    } else {
+      result += "[*]";
+    }
+  }
+  return result;
+}
 var SemanticValidator = class {
   ctx = createContext();
   symbols = null;
@@ -3063,7 +3388,23 @@ var SemanticValidator = class {
       );
     }
     if (stmt.value) {
-      this.validateExpr(stmt.value, "action");
+      const before = this.ctx.diagnostics.length;
+      const valueType = this.validateExpr(stmt.value, "action");
+      if (!this.symbols || before !== this.ctx.diagnostics.length) {
+        return;
+      }
+      const targetType = resolvePathType(stmt.path, this.symbols);
+      if (!targetType || !valueType) {
+        return;
+      }
+      const assignable = isAssignableType(valueType, targetType, this.symbols);
+      if (assignable === false) {
+        this.error(
+          `Patch value for '${renderPath(stmt.path)}' must be assignable to ${describeTypeExpr(targetType, this.symbols)}, got ${describeTypeExpr(valueType, this.symbols)}`,
+          stmt.value.location,
+          "E_TYPE_MISMATCH"
+        );
+      }
     }
   }
   validateEffect(stmt) {
@@ -3109,57 +3450,144 @@ var SemanticValidator = class {
     }
   }
   validateCondition(expr, guardType) {
-    this.validateExpr(expr, "action");
-    if (expr.kind === "literal" && typeof expr.value !== "boolean") {
-      this.warn(
-        `Condition in ${guardType} is a non-boolean literal. Consider using a boolean expression`,
+    const before = this.ctx.diagnostics.length;
+    const conditionType = this.validateExpr(expr, "action");
+    if (before === this.ctx.diagnostics.length) {
+      this.requireAssignable(
+        conditionType,
+        simpleTypeNode("boolean", expr.location),
         expr.location,
-        "W_NON_BOOL_COND"
+        `Condition in ${guardType} must evaluate to boolean`
       );
     }
   }
-  validateExpr(expr, context) {
+  validateExpr(expr, context, env = this.ctx.currentActionParamTypes) {
     switch (expr.kind) {
       case "functionCall":
-        this.validateFunctionCall(expr, context);
-        break;
-      case "binary":
-        this.validateExpr(expr.left, context);
-        this.validateExpr(expr.right, context);
-        if (expr.operator === "==" || expr.operator === "!=") {
-          this.validatePrimitiveEquality(expr.left, expr.right, expr.location);
+        this.validateFunctionCall(expr, context, env);
+        return this.inferType(expr, env);
+      case "binary": {
+        const before = this.ctx.diagnostics.length;
+        const leftType = this.validateExpr(expr.left, context, env);
+        const rightType = this.validateExpr(expr.right, context, env);
+        const hadInnerErrors = before !== this.ctx.diagnostics.length;
+        if (!hadInnerErrors) {
+          switch (expr.operator) {
+            case "==":
+            case "!=":
+              this.validatePrimitiveEquality(expr.left, expr.right, leftType, rightType, expr.location);
+              break;
+            case "<":
+            case "<=":
+            case ">":
+            case ">=":
+              this.requireAssignable(
+                leftType,
+                simpleTypeNode("number", expr.left.location),
+                expr.left.location,
+                `Operator '${expr.operator}' requires a numeric left operand`
+              );
+              this.requireAssignable(
+                rightType,
+                simpleTypeNode("number", expr.right.location),
+                expr.right.location,
+                `Operator '${expr.operator}' requires a numeric right operand`
+              );
+              break;
+            case "&&":
+            case "||":
+              this.requireAssignable(
+                leftType,
+                simpleTypeNode("boolean", expr.left.location),
+                expr.left.location,
+                `Operator '${expr.operator}' requires a boolean left operand`
+              );
+              this.requireAssignable(
+                rightType,
+                simpleTypeNode("boolean", expr.right.location),
+                expr.right.location,
+                `Operator '${expr.operator}' requires a boolean right operand`
+              );
+              break;
+            case "+":
+            case "-":
+            case "*":
+            case "/":
+            case "%":
+              this.requireAssignable(
+                leftType,
+                simpleTypeNode("number", expr.left.location),
+                expr.left.location,
+                `Operator '${expr.operator}' requires a numeric left operand`
+              );
+              this.requireAssignable(
+                rightType,
+                simpleTypeNode("number", expr.right.location),
+                expr.right.location,
+                `Operator '${expr.operator}' requires a numeric right operand`
+              );
+              break;
+            case "??":
+              this.validateCoalesceTypes([leftType, rightType], expr.location);
+              break;
+          }
         }
-        break;
-      case "unary":
-        this.validateExpr(expr.operand, context);
-        break;
-      case "ternary":
-        this.validateExpr(expr.condition, context);
-        this.validateExpr(expr.consequent, context);
-        this.validateExpr(expr.alternate, context);
-        break;
+        return this.inferType(expr, env);
+      }
+      case "unary": {
+        const before = this.ctx.diagnostics.length;
+        const operandType = this.validateExpr(expr.operand, context, env);
+        if (before === this.ctx.diagnostics.length) {
+          this.requireAssignable(
+            operandType,
+            simpleTypeNode(expr.operator === "!" ? "boolean" : "number", expr.operand.location),
+            expr.operand.location,
+            expr.operator === "!" ? "Unary '!' requires a boolean operand" : "Unary '-' requires a numeric operand"
+          );
+        }
+        return this.inferType(expr, env);
+      }
+      case "ternary": {
+        const before = this.ctx.diagnostics.length;
+        const conditionType = this.validateExpr(expr.condition, context, env);
+        this.validateExpr(expr.consequent, context, env);
+        this.validateExpr(expr.alternate, context, env);
+        if (before === this.ctx.diagnostics.length) {
+          this.requireAssignable(
+            conditionType,
+            simpleTypeNode("boolean", expr.condition.location),
+            expr.condition.location,
+            "Ternary condition must evaluate to boolean"
+          );
+        }
+        return this.inferType(expr, env);
+      }
       case "propertyAccess":
-        this.validateExpr(expr.object, context);
-        break;
+        this.validateExpr(expr.object, context, env);
+        return this.inferType(expr, env);
       case "indexAccess":
-        this.validateExpr(expr.object, context);
-        this.validateExpr(expr.index, context);
-        break;
+        this.validateExpr(expr.object, context, env);
+        this.validateExpr(expr.index, context, env);
+        return this.inferType(expr, env);
       case "objectLiteral":
         for (const prop of expr.properties) {
-          this.validateExpr(prop.value, context);
+          this.validateExpr(prop.value, context, env);
         }
-        break;
+        return this.inferType(expr, env);
       case "arrayLiteral":
         for (const elem of expr.elements) {
-          this.validateExpr(elem, context);
+          this.validateExpr(elem, context, env);
         }
-        break;
+        return this.inferType(expr, env);
       case "systemIdent":
-        break;
+        return this.inferType(expr, env);
+      case "literal":
+      case "identifier":
+      case "iterationVar":
+        return this.inferType(expr, env);
     }
   }
-  validateFunctionCall(expr, context) {
+  validateFunctionCall(expr, context, env) {
     const { name, args, location } = expr;
     if (["reduce", "fold", "foldl", "foldr", "scan"].includes(name)) {
       this.error(
@@ -3189,9 +3617,6 @@ var SemanticValidator = class {
       // FDR-MEL-042: eq/neq on primitives only
       case "eq":
       case "neq":
-        if (args.length === 2) {
-          this.validatePrimitiveEquality(args[0], args[1], location);
-        }
         break;
       // FDR-MEL-026: len() on Array only
       case "len":
@@ -3362,32 +3787,318 @@ var SemanticValidator = class {
         );
         break;
     }
-    for (const arg of args) {
-      this.validateExpr(arg, context);
+    const argTypes = [];
+    if (["filter", "map", "find", "every", "some"].includes(name) && args.length > 0) {
+      const sourceType = this.validateExpr(args[0], context, env);
+      argTypes.push(sourceType);
+      let callbackEnv = env;
+      if (this.symbols) {
+        const itemType = getArrayElementType(sourceType, this.symbols);
+        if (itemType) {
+          callbackEnv = extendCollectionTypeEnv(env, itemType);
+        }
+      }
+      for (let index = 1; index < args.length; index += 1) {
+        argTypes.push(this.validateExpr(args[index], context, index === 1 ? callbackEnv : env));
+      }
+    } else {
+      for (const arg of args) {
+        argTypes.push(this.validateExpr(arg, context, env));
+      }
+    }
+    if (!this.symbols) {
+      return;
+    }
+    switch (name) {
+      case "eq":
+      case "neq":
+        if (args.length === 2) {
+          this.validatePrimitiveEquality(args[0], args[1], argTypes[0], argTypes[1], location);
+        }
+        break;
+      case "add":
+      case "sub":
+      case "mul":
+      case "div":
+      case "mod":
+      case "pow":
+        if (args.length === 2) {
+          this.requireAssignable(
+            argTypes[0],
+            simpleTypeNode("number", args[0].location),
+            args[0].location,
+            `Function '${name}' expects a numeric first argument`
+          );
+          this.requireAssignable(
+            argTypes[1],
+            simpleTypeNode("number", args[1].location),
+            args[1].location,
+            `Function '${name}' expects a numeric second argument`
+          );
+        }
+        break;
+      case "gt":
+      case "gte":
+      case "lt":
+      case "lte":
+        if (args.length === 2) {
+          this.requireAssignable(
+            argTypes[0],
+            simpleTypeNode("number", args[0].location),
+            args[0].location,
+            `Function '${name}' expects a numeric first argument`
+          );
+          this.requireAssignable(
+            argTypes[1],
+            simpleTypeNode("number", args[1].location),
+            args[1].location,
+            `Function '${name}' expects a numeric second argument`
+          );
+        }
+        break;
+      case "and":
+      case "or":
+        for (const [index, arg] of args.entries()) {
+          this.requireAssignable(
+            argTypes[index],
+            simpleTypeNode("boolean", arg.location),
+            arg.location,
+            `Function '${name}' expects boolean arguments`
+          );
+        }
+        break;
+      case "not":
+        if (args.length === 1) {
+          this.requireAssignable(
+            argTypes[0],
+            simpleTypeNode("boolean", args[0].location),
+            args[0].location,
+            "Function 'not' expects a boolean argument"
+          );
+        }
+        break;
+      case "neg":
+      case "abs":
+      case "floor":
+      case "ceil":
+      case "round":
+      case "sqrt":
+        if (args.length === 1) {
+          this.requireAssignable(
+            argTypes[0],
+            simpleTypeNode("number", args[0].location),
+            args[0].location,
+            `Function '${name}' expects a numeric argument`
+          );
+        }
+        break;
+      case "trim":
+      case "lower":
+      case "upper":
+      case "strlen":
+        if (args.length === 1) {
+          this.requireAssignable(
+            argTypes[0],
+            simpleTypeNode("string", args[0].location),
+            args[0].location,
+            `Function '${name}' expects a string argument`
+          );
+        }
+        break;
+      case "startsWith":
+      case "endsWith":
+      case "strIncludes":
+      case "indexOf":
+      case "split":
+        if (args.length === 2) {
+          this.requireAssignable(
+            argTypes[0],
+            simpleTypeNode("string", args[0].location),
+            args[0].location,
+            `Function '${name}' expects a string first argument`
+          );
+          this.requireAssignable(
+            argTypes[1],
+            simpleTypeNode("string", args[1].location),
+            args[1].location,
+            `Function '${name}' expects a string second argument`
+          );
+        }
+        break;
+      case "replace":
+        if (args.length >= 2) {
+          this.requireAssignable(
+            argTypes[0],
+            simpleTypeNode("string", args[0].location),
+            args[0].location,
+            "Function 'replace' expects a string first argument"
+          );
+          this.requireAssignable(
+            argTypes[1],
+            simpleTypeNode("string", args[1].location),
+            args[1].location,
+            "Function 'replace' expects a string second argument"
+          );
+        }
+        if (args.length === 3) {
+          this.requireAssignable(
+            argTypes[2],
+            simpleTypeNode("string", args[2].location),
+            args[2].location,
+            "Function 'replace' expects a string replacement argument"
+          );
+        }
+        break;
+      case "substring":
+      case "substr":
+        if (args.length >= 2) {
+          this.requireAssignable(
+            argTypes[0],
+            simpleTypeNode("string", args[0].location),
+            args[0].location,
+            `Function '${name}' expects a string first argument`
+          );
+          this.requireAssignable(
+            argTypes[1],
+            simpleTypeNode("number", args[1].location),
+            args[1].location,
+            `Function '${name}' expects a numeric second argument`
+          );
+        }
+        if (args.length === 3) {
+          this.requireAssignable(
+            argTypes[2],
+            simpleTypeNode("number", args[2].location),
+            args[2].location,
+            `Function '${name}' expects a numeric third argument`
+          );
+        }
+        break;
+      case "len":
+        if (args.length === 1) {
+          this.requireLenCompatible(argTypes[0], args[0].location);
+        }
+        break;
+      case "filter":
+      case "find":
+      case "every":
+      case "some":
+        if (args.length === 2) {
+          this.requireArrayCompatible(argTypes[0], args[0].location, name);
+          this.requireAssignable(
+            argTypes[1],
+            simpleTypeNode("boolean", args[1].location),
+            args[1].location,
+            `Function '${name}' requires a boolean-valued callback`
+          );
+        }
+        break;
+      case "map":
+        if (args.length === 2) {
+          this.requireArrayCompatible(argTypes[0], args[0].location, name);
+        }
+        break;
+      case "coalesce":
+        this.validateCoalesceTypes(argTypes, location);
+        break;
+      case "if":
+      case "cond":
+        if (args.length === 3) {
+          this.requireAssignable(
+            argTypes[0],
+            simpleTypeNode("boolean", args[0].location),
+            args[0].location,
+            `Function '${name}' expects a boolean condition`
+          );
+        }
+        break;
+    }
+  }
+  validatePrimitiveEquality(leftExpr, rightExpr, leftType, rightType, location) {
+    if (!this.symbols) {
+      return;
+    }
+    if (leftExpr.kind === "objectLiteral" || leftExpr.kind === "arrayLiteral" || rightExpr.kind === "objectLiteral" || rightExpr.kind === "arrayLiteral") {
+      this.error(
+        "eq/neq operands must be compatible primitive types, not object or array literals",
+        location,
+        "E_TYPE_MISMATCH"
+      );
+      return;
+    }
+    const compatible = areComparableTypesCompatible(leftType, rightType, this.symbols);
+    if (compatible === false) {
+      this.error(
+        `eq/neq operands must be compatible primitive types, got ${describeTypeExpr(leftType, this.symbols)} and ${describeTypeExpr(rightType, this.symbols)}`,
+        location,
+        "E_TYPE_MISMATCH"
+      );
     }
   }
-  validatePrimitiveEquality(left, right, location) {
+  inferType(expr, env) {
     if (!this.symbols) {
+      return null;
+    }
+    return inferExprType(expr, env, this.symbols);
+  }
+  requireAssignable(actualType, expectedType, location, message) {
+    if (!this.symbols || !actualType) {
       return;
     }
-    const leftClass = classifyComparableExpr(
-      left,
-      this.ctx.currentActionParamTypes,
-      this.symbols
-    );
-    const rightClass = classifyComparableExpr(
-      right,
-      this.ctx.currentActionParamTypes,
-      this.symbols
-    );
-    if (leftClass === "nonprimitive" || rightClass === "nonprimitive") {
+    const assignable = isAssignableType(actualType, expectedType, this.symbols);
+    if (assignable === false) {
       this.error(
-        "eq/neq operands must be primitive types (null, boolean, number, string)",
+        `${message}, got ${describeTypeExpr(actualType, this.symbols)}`,
         location,
         "E_TYPE_MISMATCH"
       );
     }
   }
+  requireArrayCompatible(actualType, location, fnName) {
+    if (!this.symbols || !actualType) {
+      return;
+    }
+    const outcome = classifyArrayOperand(actualType, this.symbols);
+    if (outcome === false) {
+      this.error(
+        `Function '${fnName}' expects an array first argument, got ${describeTypeExpr(actualType, this.symbols)}`,
+        location,
+        "E_TYPE_MISMATCH"
+      );
+    }
+  }
+  requireLenCompatible(actualType, location) {
+    if (!this.symbols || !actualType) {
+      return;
+    }
+    const outcome = classifyLenOperand(actualType, this.symbols);
+    if (outcome === false) {
+      this.error(
+        `Function 'len' expects a string, array, object, or record argument, got ${describeTypeExpr(actualType, this.symbols)}`,
+        location,
+        "E_TYPE_MISMATCH"
+      );
+    }
+  }
+  validateCoalesceTypes(types, location) {
+    if (!this.symbols) {
+      return;
+    }
+    const concreteTypes = types.map((typeExpr) => stripNullType(typeExpr, this.symbols)).filter((typeExpr) => typeExpr !== null);
+    for (let i = 0; i < concreteTypes.length; i += 1) {
+      for (let j = i + 1; j < concreteTypes.length; j += 1) {
+        const compatible = areTypesCompatible(concreteTypes[i], concreteTypes[j], this.symbols);
+        if (compatible === false) {
+          this.error(
+            `coalesce arguments must have compatible non-null types, got ${describeTypeExpr(concreteTypes[i], this.symbols)} and ${describeTypeExpr(concreteTypes[j], this.symbols)}`,
+            location,
+            "E_TYPE_MISMATCH"
+          );
+          return;
+        }
+      }
+    }
+  }
   error(message, location, code) {
     this.ctx.diagnostics.push({
       severity: "error",
@@ -4635,7 +5346,7 @@ function typeExprToFieldSpec(typeExpr, ctx, seenTypeRefs = []) {
         pushSchemaTypeError(
           ctx,
           "E045",
-          `Nullable type '${describeTypeExpr(typeExpr)}' cannot be lowered to FieldSpec`,
+          `Nullable type '${describeTypeExpr2(typeExpr)}' cannot be lowered to FieldSpec`,
           typeExpr.location
         );
         return null;
@@ -4643,7 +5354,7 @@ function typeExprToFieldSpec(typeExpr, ctx, seenTypeRefs = []) {
       pushSchemaTypeError(
         ctx,
         "E043",
-        `Union type '${describeTypeExpr(typeExpr)}' cannot be soundly lowered to FieldSpec`,
+        `Union type '${describeTypeExpr2(typeExpr)}' cannot be soundly lowered to FieldSpec`,
         typeExpr.location
       );
       return null;
@@ -4663,7 +5374,7 @@ function typeExprToFieldSpec(typeExpr, ctx, seenTypeRefs = []) {
       pushSchemaTypeError(
         ctx,
         "E046",
-        `Record type '${describeTypeExpr(typeExpr)}' cannot be lowered to FieldSpec`,
+        `Record type '${describeTypeExpr2(typeExpr)}' cannot be lowered to FieldSpec`,
         typeExpr.location
       );
       return null;
@@ -4700,20 +5411,20 @@ function pushSchemaTypeError(ctx, code, message, location) {
     location
   });
 }
-function describeTypeExpr(typeExpr) {
+function describeTypeExpr2(typeExpr) {
   switch (typeExpr.kind) {
     case "simpleType":
       return typeExpr.name;
     case "unionType":
-      return typeExpr.types.map((member) => describeTypeExpr(member)).join(" | ");
+      return typeExpr.types.map((member) => describeTypeExpr2(member)).join(" | ");
     case "arrayType":
-      return `Array<${describeTypeExpr(typeExpr.elementType)}>`;
+      return `Array<${describeTypeExpr2(typeExpr.elementType)}>`;
     case "recordType":
-      return `Record<${describeTypeExpr(typeExpr.keyType)}, ${describeTypeExpr(typeExpr.valueType)}>`;
+      return `Record<${describeTypeExpr2(typeExpr.keyType)}, ${describeTypeExpr2(typeExpr.valueType)}>`;
     case "literalType":
       return JSON.stringify(typeExpr.value);
     case "objectType":
-      return `{ ${typeExpr.fields.map((field) => `${field.name}${field.optional ? "?" : ""}: ${describeTypeExpr(field.typeExpr)}`).join("; ")} }`;
+      return `{ ${typeExpr.fields.map((field) => `${field.name}${field.optional ? "?" : ""}: ${describeTypeExpr2(field.typeExpr)}`).join("; ")} }`;
   }
 }
 function validateLiteralAgainstSpec(value, spec, fieldName, location, ctx) {
@@ -6917,4 +7628,4 @@ export {
   compileMelDomain,
   compileMelPatch
 };
-//# sourceMappingURL=chunk-MKLDAZ2Z.js.map
+//# sourceMappingURL=chunk-4JJQCFJH.js.map