Done config

internal/confmgr/model.go

@@ -16,16 +16,17 @@ import (
 type ParamType string
 
 const (
-	TypeFloat  ParamType = "float64"
-	TypeInt    ParamType = "int64"
-	TypeBool   ParamType = "bool"
-	TypeString ParamType = "string"
-	TypeEnum   ParamType = "enum"
+	TypeFloat      ParamType = "float64"
+	TypeInt        ParamType = "int64"
+	TypeBool       ParamType = "bool"
+	TypeString     ParamType = "string"
+	TypeEnum       ParamType = "enum"
+	TypeFloatArray ParamType = "float64[]" // waveform; value is a list of numbers
 )
 
 func (t ParamType) valid() bool {
 	switch t {
-	case TypeFloat, TypeInt, TypeBool, TypeString, TypeEnum:
+	case TypeFloat, TypeInt, TypeBool, TypeString, TypeEnum, TypeFloatArray:
 		return true
 	}
 	return false
@@ -197,10 +198,57 @@ func (p Parameter) checkValue(v any) error {
 		if !slices.Contains(p.EnumValues, s) {
 			return fmt.Errorf("value %q is not an allowed enum value", s)
 		}
+	case TypeFloatArray:
+		arr, err := toFloatArray(v)
+		if err != nil {
+			return err
+		}
+		for i, f := range arr {
+			if p.Min != nil && f < *p.Min {
+				return fmt.Errorf("element %d value %v below minimum %v", i, f, *p.Min)
+			}
+			if p.Max != nil && f > *p.Max {
+				return fmt.Errorf("element %d value %v above maximum %v", i, f, *p.Max)
+			}
+		}
 	}
 	return nil
 }
 
+// normalize coerces a JSON-decoded value into the canonical Go type the
+// datasource write path expects. Array parameters become []float64 (JSON yields
+// []any); scalar values are returned unchanged.
+func (p Parameter) normalize(v any) any {
+	if p.Type == TypeFloatArray {
+		if arr, err := toFloatArray(v); err == nil {
+			return arr
+		}
+	}
+	return v
+}
+
+// toFloatArray coerces a JSON-decoded array value to []float64. JSON
+// unmarshalling yields []any of float64, but a native []float64 is also
+// accepted.
+func toFloatArray(v any) ([]float64, error) {
+	switch a := v.(type) {
+	case []float64:
+		return a, nil
+	case []any:
+		out := make([]float64, len(a))
+		for i, e := range a {
+			f, err := toFloat(e)
+			if err != nil {
+				return nil, fmt.Errorf("element %d: %w", i, err)
+			}
+			out[i] = f
+		}
+		return out, nil
+	default:
+		return nil, fmt.Errorf("value %v is not an array", v)
+	}
+}
+
 // toFloat coerces a JSON-decoded numeric value to float64. JSON unmarshalling
 // yields float64 for numbers, but values may also arrive as int or string.
 func toFloat(v any) (float64, error) {