Fix keyword color support in compile/lower and distribution edge cases

- compile.clj node->fill-descriptor: handle keyword fills (:red) in
  addition to vector fills, fixing crash when keywords meet effects
- lower.clj inherit-fill: same keyword support for inherited fills
- prob.clj Pareto sampling: add 10000-iteration guard to prevent
  infinite loop when :max <= :min
- prob.clj triangular distribution: return min when min == max instead
  of dividing by zero

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: leifericf

src/eido/engine/compile.clj

@@ -337,7 +337,7 @@
     (nil? fill)                                          nil
     (and (map? fill) (#{:hatch :stipple} (:fill/type fill))) fill
     (and (map? fill) (= :pattern (:fill/type fill)))     fill
-    (vector? fill)                                       {:fill/type :fill/solid :color fill}
+    (or (vector? fill) (keyword? fill))                    {:fill/type :fill/solid :color fill}
     (:gradient/type fill)                                (merge {:fill/type :fill/gradient} fill)
     (:color fill)                                        {:fill/type :fill/solid :color (:color fill)}
     :else                                                fill))

src/eido/gen/prob.clj

@@ -136,21 +136,25 @@
                           mx (:max spec)]
                       (if mx
                         (let [mx (double mx)]
-                          (loop []
-                            (let [v (* mn (Math/pow (- 1.0 (.nextDouble rng))
-                                                    (/ -1.0 alpha)))]
-                              (if (<= v mx) v (recur)))))
+                          (loop [tries 0]
+                            (if (>= tries 10000)
+                              mn
+                              (let [v (* mn (Math/pow (- 1.0 (.nextDouble rng))
+                                                      (/ -1.0 alpha)))]
+                                (if (<= v mx) v (recur (inc tries)))))))
                         (* mn (Math/pow (- 1.0 (.nextDouble rng))
                                         (/ -1.0 alpha)))))
     :triangular     (let [rng (make-rng seed)
                           mn (double (:min spec))
                           mx (double (:max spec))
-                          mode (double (:mode spec))
-                          u (.nextDouble rng)
-                          fc (/ (- mode mn) (- mx mn))]
-                      (if (< u fc)
-                        (+ mn (Math/sqrt (* u (- mx mn) (- mode mn))))
-                        (- mx (Math/sqrt (* (- 1.0 u) (- mx mn) (- mx mode))))))
+                          mode (double (:mode spec))]
+                      (if (== mn mx)
+                        mn
+                        (let [u (.nextDouble rng)
+                              fc (/ (- mode mn) (- mx mn))]
+                          (if (< u fc)
+                            (+ mn (Math/sqrt (* u (- mx mn) (- mode mn))))
+                            (- mx (Math/sqrt (* (- 1.0 u) (- mx mn) (- mx mode))))))))
     :eased          (let [rng (make-rng seed)
                           easing (:easing spec)
                           lo (double (get spec :lo 0))

src/eido/ir/lower.clj

@@ -271,7 +271,8 @@
     (let [fill (:style/fill ctx-style)]
       (assoc item :item/fill
         (cond
-          (vector? fill)         {:fill/type :fill/solid :color fill}
+          (or (vector? fill)
+              (keyword? fill))   {:fill/type :fill/solid :color fill}
           (:gradient/type fill)  (merge {:fill/type :fill/gradient} fill)
           (:color fill)          {:fill/type :fill/solid :color (:color fill)}
           :else                  fill)))