From 7b0ea5968dc18e65c08e8262ba0199920f498214 Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:30:22 +0000
Subject: [PATCH 01/13] :ambulance: Fix typo :podition in swap-shapes grid cell

The key :podition was used instead of :position when updating the
id-from cell in swap-shapes, silently discarding the position value
and leaving the cell's :position as nil after every swap.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/shape/layout.cljc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/src/app/common/types/shape/layout.cljc b/common/src/app/common/types/shape/layout.cljc
index 384029a688..8ed7306c61 100644
--- a/common/src/app/common/types/shape/layout.cljc
+++ b/common/src/app/common/types/shape/layout.cljc
@@ -1439,7 +1439,7 @@
         (update-in [:layout-grid-cells id-from]
                    assoc
                    :shapes (:shapes cell-to)
-                   :podition (:position cell-to))
+                   :position (:position cell-to))
         (update-in [:layout-grid-cells id-to]
                    assoc
                    :shapes (:shapes cell-from)

From 08ca56166714a29bf7a4e2ea1435c7370091954c Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:30:30 +0000
Subject: [PATCH 02/13] :bug: Add better nil handling in interpolate-gradient
 when offset exceeds stops

When no gradient stop satisfies (<= offset (:offset %)),
d/index-of-pred returns nil. The previous code called (dec nil) in
the start binding before the nil check, throwing a
NullPointerException/ClassCastException. Guard the start binding with
a cond that handles nil before attempting dec.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/color.cljc | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/common/src/app/common/types/color.cljc b/common/src/app/common/types/color.cljc
index c4532c4ac0..ae56250d96 100644
--- a/common/src/app/common/types/color.cljc
+++ b/common/src/app/common/types/color.cljc
@@ -720,8 +720,10 @@
 
 (defn- offset-spread
   [from to num]
-  (->> (range 0 num)
-       (map #(mth/precision (+ from (* (/ (- to from) (dec num)) %)) 2))))
+  (if (<= num 1)
+    [from]
+    (->> (range 0 num)
+         (map #(mth/precision (+ from (* (/ (- to from) (dec num)) %)) 2)))))
 
 (defn uniform-spread?
   "Checks if the gradient stops are spread uniformly"
@@ -750,6 +752,9 @@
 (defn interpolate-gradient
   [stops offset]
   (let [idx   (d/index-of-pred stops #(<= offset (:offset %)))
-        start (if (= idx 0) (first stops) (get stops (dec idx)))
+        start (cond
+                (nil? idx) (last stops)
+                (= idx 0)  (first stops)
+                :else      (get stops (dec idx)))
         end   (if (nil? idx) (last stops) (get stops idx))]
     (interpolate-color start end offset)))

From ff41d08e3c726a08b447066630d17ecc6769a22a Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:30:35 +0000
Subject: [PATCH 03/13] :bug: Fix stale accumulator in get-children-in-instance
 recursion

get-children-rec passed the original children vector to each recursive
call instead of the updated one that already includes the current
shape. This caused descendant results to be accumulated from the wrong
starting point, losing intermediate shapes. Pass children' (which
includes the current shape) into every recursive call.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/container.cljc | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/common/src/app/common/types/container.cljc b/common/src/app/common/types/container.cljc
index 324528854b..8bb0e7d969 100644
--- a/common/src/app/common/types/container.cljc
+++ b/common/src/app/common/types/container.cljc
@@ -106,8 +106,9 @@
             (let [shape (get objects id)]
               (if (and (ctk/instance-head? shape) (seq children))
                 children
-                (into (conj children shape)
-                      (mapcat #(get-children-rec children %) (:shapes shape))))))]
+                (let [children' (conj children shape)]
+                  (into children'
+                        (mapcat #(get-children-rec children' %) (:shapes shape)))))))]
     (get-children-rec [] id)))
 
 (defn get-component-shape

From c30c85ff077179627401fc831b229362b5ca3064 Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:30:50 +0000
Subject: [PATCH 04/13] :bug: Remove duplicate font-weight-keys in
 typography-keys union

font-weight-keys was listed twice in the set/union call for
typography-keys, a copy-paste error. The duplicate entry has no
functional effect (sets deduplicate), but it is misleading and
suggests a missing key such as font-style-keys in its place.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/token.cljc | 1 -
 1 file changed, 1 deletion(-)

diff --git a/common/src/app/common/types/token.cljc b/common/src/app/common/types/token.cljc
index e3e541da33..c3bb2b266d 100644
--- a/common/src/app/common/types/token.cljc
+++ b/common/src/app/common/types/token.cljc
@@ -345,7 +345,6 @@
 (def typography-keys (set/union font-family-keys
                                 font-size-keys
                                 font-weight-keys
-                                font-weight-keys
                                 letter-spacing-keys
                                 line-height-keys
                                 text-case-keys

From 8253738f01c9709fef18e35a5aac412690a438ee Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:34:38 +0000
Subject: [PATCH 05/13] :bug: Fix reversed `get` args in
 convert-dtcg-shadow-composite

\`(get "type" shadow)\` always returns nil because the map and key
arguments were swapped. The correct call is \`(get shadow "type")\`,
which allows the legacy innerShadow detection to work correctly.
Update the test expectation accordingly.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/tokens_lib.cljc         | 2 +-
 common/test/common_tests/types/tokens_lib_test.cljc | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/common/src/app/common/types/tokens_lib.cljc b/common/src/app/common/types/tokens_lib.cljc
index 5c392f2db9..8ab9c6bcd0 100644
--- a/common/src/app/common/types/tokens_lib.cljc
+++ b/common/src/app/common/types/tokens_lib.cljc
@@ -1637,7 +1637,7 @@ Will return a value that matches this schema:
   [value]
   (let [process-shadow (fn [shadow]
                          (if (map? shadow)
-                           (let [legacy-shadow-type (get "type" shadow)]
+                           (let [legacy-shadow-type (get shadow "type")]
                              (-> shadow
                                  (set/rename-keys {"x" :offset-x
                                                    "offsetX" :offset-x
diff --git a/common/test/common_tests/types/tokens_lib_test.cljc b/common/test/common_tests/types/tokens_lib_test.cljc
index 150ffcfb08..e8c8a52ae5 100644
--- a/common/test/common_tests/types/tokens_lib_test.cljc
+++ b/common/test/common_tests/types/tokens_lib_test.cljc
@@ -1918,7 +1918,7 @@
          (let [token (ctob/get-token-by-name lib "shadow-test" "test.shadow-with-type")]
            (t/is (some? token))
            (t/is (= :shadow (:type token)))
-           (t/is (= [{:offset-x "0", :offset-y "4px", :blur "8px", :spread "0", :color "rgba(0,0,0,0.2)", :inset false}]
+           (t/is (= [{:offset-x "0", :offset-y "4px", :blur "8px", :spread "0", :color "rgba(0,0,0,0.2)", :inset true}]
                     (:value token)))))
 
        (t/testing "shadow token with description"

From 8b08c8ecc974eb805fcd59bfa7008eb6c6a58a4e Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:35:21 +0000
Subject: [PATCH 06/13] :bug: Fix wrong mapcat call in collect-main-shapes

`(mapcat collect-main-shapes children objects)` passes `objects` as a
second parallel collection instead of threading it as the second
argument to `collect-main-shapes` for each child. Fix by using an
anonymous fn: `(mapcat #(collect-main-shapes % objects) children)`.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/container.cljc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/src/app/common/types/container.cljc b/common/src/app/common/types/container.cljc
index 8bb0e7d969..b72ca11179 100644
--- a/common/src/app/common/types/container.cljc
+++ b/common/src/app/common/types/container.cljc
@@ -441,7 +441,7 @@
   (if (ctk/main-instance? shape)
     [shape]
     (if-let [children (cfh/get-children objects (:id shape))]
-      (mapcat collect-main-shapes children objects)
+      (mapcat #(collect-main-shapes % objects) children)
       [])))
 
 (defn get-component-from-shape

From 2b67e114b6ce894d3d74d6106c4ef4e630fda687 Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:37:01 +0000
Subject: [PATCH 07/13] :bug: Fix inside-layout? passing id instead of shape to
 frame-shape?

`(cfh/frame-shape? current-id)` passes a UUID to the single-arity
overload of `frame-shape?`, which expects a shape map; it always
returns false. Fix by passing `current` (the resolved shape) instead.
Update the test to assert the correct behaviour.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/shape/layout.cljc         | 2 +-
 common/test/common_tests/types/shape_layout_test.cljc | 8 ++------
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/common/src/app/common/types/shape/layout.cljc b/common/src/app/common/types/shape/layout.cljc
index 8ed7306c61..caea9d5f91 100644
--- a/common/src/app/common/types/shape/layout.cljc
+++ b/common/src/app/common/types/shape/layout.cljc
@@ -262,7 +262,7 @@
         (or (nil? current) (= current-id parent-id))
         false
 
-        (cfh/frame-shape? current-id)
+        (cfh/frame-shape? current)
         (:layout current)
 
         :else
diff --git a/common/test/common_tests/types/shape_layout_test.cljc b/common/test/common_tests/types/shape_layout_test.cljc
index d677ed5d09..62935b21dc 100644
--- a/common/test/common_tests/types/shape_layout_test.cljc
+++ b/common/test/common_tests/types/shape_layout_test.cljc
@@ -186,13 +186,9 @@
         flex (make-flex-frame :parent-id root-id)
         child (make-shape :parent-id (:id flex))]
 
-    ;; Note: inside-layout? calls (cfh/frame-shape? current-id) with a UUID id,
-    ;; but frame-shape? checks (:type uuid) which is nil for a UUID value.
-    ;; The function therefore always returns false regardless of structure.
-    ;; These tests document the actual (not the intended) behavior.
-    (t/testing "returns false when child is under a flex frame"
+    (t/testing "returns true when child is under a flex frame"
       (let [objects {root-id root (:id flex) flex (:id child) child}]
-        (t/is (not (layout/inside-layout? objects child)))))
+        (t/is (layout/inside-layout? objects child))))
 
     (t/testing "returns false for root shape"
       (let [objects {root-id root (:id flex) flex (:id child) child}]

From 6da39bc9c74539697b8d07162fa03d329976a6e7 Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:41:00 +0000
Subject: [PATCH 08/13] :bug: Fix ObjectsMap CLJS negative cache keyed on 'key'
 fn instead of 'k'

In the CLJS -lookup implementation, when a key is absent from data the
negative cache entry was stored under 'key' (the built-in map-entry
key function) rather than the 'k' parameter.  As a result every
subsequent lookup of any missing key bypassed the cache and repeated
the full lookup path, making the negative-cache optimization entirely
ineffective.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/objects_map.cljc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/src/app/common/types/objects_map.cljc b/common/src/app/common/types/objects_map.cljc
index d08330765c..3604961f11 100644
--- a/common/src/app/common/types/objects_map.cljc
+++ b/common/src/app/common/types/objects_map.cljc
@@ -278,7 +278,7 @@
                (set! (.-cache this) (c/-assoc cache k v))
                v)
              (do
-               (set! (.-cache this) (assoc cache key nil))
+               (set! (.-cache this) (assoc cache k nil))
                nil))))
 
      (-lookup [this k not-found]

From 30931839b5d136f1e543665061a47d7f4fee27c6 Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:43:32 +0000
Subject: [PATCH 09/13] :bug: Fix reversed d/in-range? args in CLJS Fills -nth
 with default

In the ClojureScript Fills deftype, the two-arity -nth implementation
called (d/in-range? i size) but the signature is (d/in-range? size i).
This meant -nth always fell through to the default value for any valid
index when called with an explicit default, since i < size is the
condition but the args were swapped.

The no-default -nth sibling on line 378 and both CLJ nth impls on
lines 286 and 291 had the correct argument order.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/fills/impl.cljc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/src/app/common/types/fills/impl.cljc b/common/src/app/common/types/fills/impl.cljc
index 06475d183f..b429c67b9c 100644
--- a/common/src/app/common/types/fills/impl.cljc
+++ b/common/src/app/common/types/fills/impl.cljc
@@ -380,7 +380,7 @@
          nil))
 
      (-nth [_ i default]
-       (if (d/in-range? i size)
+       (if (d/in-range? size i)
          (read-fill dbuffer mbuffer i)
          default))
 

From caac452cd4ddc45b368bfda8764453baf81da6de Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:44:58 +0000
Subject: [PATCH 10/13] :bug: Fix wrong extremity point in
 calculate-extremities for line-to

In the :line-to branch of calculate-extremities, move-p (the subpath
start point) was being added to the extremities set instead of from-p
(the actual previous point). For all line segments beyond the first one
in a subpath this produced an incorrect bounding-box start point.

The :curve-to branch correctly used from-p; align :line-to to match.
Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/types/path/segment.cljc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/src/app/common/types/path/segment.cljc b/common/src/app/common/types/path/segment.cljc
index bcbbe8eeda..45fc1ba2bb 100644
--- a/common/src/app/common/types/path/segment.cljc
+++ b/common/src/app/common/types/path/segment.cljc
@@ -812,7 +812,7 @@
             :line-to
             (recur (cond-> points
                      (and from-p to-p)
-                     (-> (conj! move-p)
+                     (-> (conj! from-p)
                          (conj! to-p)))
                    (not-empty (subvec content 1))
                    to-p

From db7c6465681435e180bf0d4c148fd2e324d64aa9 Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 12:48:07 +0000
Subject: [PATCH 11/13] :sparkles: Add missing tests for session bug fixes and
 uniform-spread?

Add indexed-access-with-default in fill_test.cljc to cover the two-arity
(nth fills i default) form on both valid and out-of-range indices, directly
exercising the CLJS Fills -nth path fixed in 593cf125.

Add segment-content->selrect-multi-line in path_data_test.cljc to cover
content->selrect on a subpath with multiple consecutive line-to commands
where move-p diverges from from-p, confirming the bounding box matches
both the expected coordinates and the reference implementation; this
guards the calculate-extremities fix in bb5a04c7.

Add types-uniform-spread? in colors_test.cljc to cover
app.common.types.color/uniform-spread?, which had no dedicated tests.
Exercises the uniform case (via uniform-spread), the two-stop edge case,
wrong-offset detection, and wrong-color detection.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/test/common_tests/colors_test.cljc     | 21 ++++++++++++++++
 common/test/common_tests/types/fill_test.cljc | 15 +++++++++++
 .../common_tests/types/path_data_test.cljc    | 25 +++++++++++++++++++
 3 files changed, 61 insertions(+)

diff --git a/common/test/common_tests/colors_test.cljc b/common/test/common_tests/colors_test.cljc
index de505fd540..aa1edd450a 100644
--- a/common/test/common_tests/colors_test.cljc
+++ b/common/test/common_tests/colors_test.cljc
@@ -426,6 +426,27 @@
                {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
     (t/is (false? (c/uniform-spread? stops)))))
 
+(t/deftest types-uniform-spread?
+  (t/testing "uniformly spread stops are detected as uniform"
+    (let [c1    {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2    {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          stops (colors/uniform-spread c1 c2 3)]
+      (t/is (true? (colors/uniform-spread? stops)))))
+  (t/testing "two-stop gradient is uniform by definition"
+    (let [stops [{:color "#ff0000" :opacity 1.0 :offset 0.0}
+                 {:color "#0000ff" :opacity 1.0 :offset 1.0}]]
+      (t/is (true? (colors/uniform-spread? stops)))))
+  (t/testing "stops with wrong offset are not uniform"
+    (let [stops [{:color "#000000" :opacity 0.0 :offset 0.0}
+                 {:color "#888888" :opacity 0.5 :offset 0.3}
+                 {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
+      (t/is (false? (colors/uniform-spread? stops)))))
+  (t/testing "stops with correct offset but wrong color are not uniform"
+    (let [stops [{:color "#000000" :opacity 0.0 :offset 0.0}
+                 {:color "#aaaaaa" :opacity 0.5 :offset 0.5}
+                 {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
+      (t/is (false? (colors/uniform-spread? stops))))))
+
 (t/deftest ac-interpolate-gradient
   (let [stops [{:color "#000000" :opacity 0.0 :offset 0.0}
                {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
diff --git a/common/test/common_tests/types/fill_test.cljc b/common/test/common_tests/types/fill_test.cljc
index 308778bcc1..f9968e8aed 100644
--- a/common/test/common_tests/types/fill_test.cljc
+++ b/common/test/common_tests/types/fill_test.cljc
@@ -207,3 +207,18 @@
         fill1  (nth fills1 1)]
     (t/is (nil? fill1))
     (t/is (equivalent-fill? fill0 sample-fill-6))))
+
+(t/deftest indexed-access-with-default
+  (t/testing "nth with default returns fill for valid index"
+    ;; Regression: CLJS -nth with default had reversed d/in-range? args,
+    ;; so it always fell through to the default even for valid indices.
+    (let [fills    (types.fills/from-plain [sample-fill-6])
+          sentinel ::not-found
+          result   (nth fills 0 sentinel)]
+      (t/is (not= sentinel result))
+      (t/is (equivalent-fill? result sample-fill-6))))
+  (t/testing "nth with default returns default for out-of-range index"
+    (let [fills    (types.fills/from-plain [sample-fill-6])
+          sentinel ::not-found]
+      (t/is (= sentinel (nth fills 1 sentinel)))
+      (t/is (= sentinel (nth fills -1 sentinel))))))
diff --git a/common/test/common_tests/types/path_data_test.cljc b/common/test/common_tests/types/path_data_test.cljc
index e4d2881b18..6dc7fa5207 100644
--- a/common/test/common_tests/types/path_data_test.cljc
+++ b/common/test/common_tests/types/path_data_test.cljc
@@ -973,6 +973,31 @@
     (t/is (mth/close? 10.0 (:x2 rect) 0.1))
     (t/is (mth/close? 10.0 (:y2 rect) 0.1))))
 
+(t/deftest segment-content->selrect-multi-line
+  ;; Regression: calculate-extremities used move-p instead of from-p in
+  ;; the :line-to branch. For a subpath with multiple consecutive line-to
+  ;; commands, the selrect must still match the reference implementation.
+  (let [;; A subpath that starts away from the origin and has three
+        ;; line-to segments so that move-p diverges from from-p for the
+        ;; later segments.
+        segments [{:command :move-to :params {:x 5.0  :y 5.0}}
+                  {:command :line-to :params {:x 15.0 :y 0.0}}
+                  {:command :line-to :params {:x 20.0 :y 8.0}}
+                  {:command :line-to :params {:x 10.0 :y 12.0}}]
+        content  (path/content segments)
+        rect     (path.segment/content->selrect content)
+        ref-pts  (calculate-extremities segments)]
+
+    ;; Bounding box must enclose all four vertices exactly.
+    (t/is (some? rect))
+    (t/is (mth/close?  5.0 (:x1 rect) 0.1))
+    (t/is (mth/close?  0.0 (:y1 rect) 0.1))
+    (t/is (mth/close? 20.0 (:x2 rect) 0.1))
+    (t/is (mth/close? 12.0 (:y2 rect) 0.1))
+
+    ;; Must agree with the reference implementation.
+    (t/is (= ref-pts (calculate-extremities content)))))
+
 (t/deftest segment-content-center
   (let [content (path/content sample-content-square)
         center  (path.segment/content-center content)]

From 1e0f10814ed65b32d09cf6943983b3210c3425a6 Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 19:04:04 +0000
Subject: [PATCH 12/13] :fire: Remove duplicate gradient helpers from
 app.common.colors

The five functions interpolate-color, offset-spread, uniform-spread?,
uniform-spread, and interpolate-gradient duplicated the canonical
implementations in app.common.types.color. The copies in colors.cljc
also contained two bugs: a division-by-zero in offset-spread when
num=1, and a crash on nil idx in interpolate-gradient.

All production callers already use app.common.types.color. The
duplicate tests that exercised the old copies are removed; their
coverage is absorbed into expanded tests under the types-* suite,
including a new nil-idx guard test and a single-stop no-crash test.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/src/app/common/colors.cljc         | 59 --------------
 common/test/common_tests/colors_test.cljc | 94 ++++++++++++-----------
 2 files changed, 50 insertions(+), 103 deletions(-)

diff --git a/common/src/app/common/colors.cljc b/common/src/app/common/colors.cljc
index e16acf94a3..ab7c7e2a76 100644
--- a/common/src/app/common/colors.cljc
+++ b/common/src/app/common/colors.cljc
@@ -487,62 +487,3 @@
         b (+ (* bh 100) (* bv 10))]
     (compare a b)))
 
-(defn interpolate-color
-  [c1 c2 offset]
-  (cond
-    (<= offset (:offset c1)) (assoc c1 :offset offset)
-    (>= offset (:offset c2)) (assoc c2 :offset offset)
-
-    :else
-    (let [tr-offset (/ (- offset (:offset c1)) (- (:offset c2) (:offset c1)))
-          [r1 g1 b1] (hex->rgb (:color c1))
-          [r2 g2 b2] (hex->rgb (:color c2))
-          a1 (:opacity c1)
-          a2 (:opacity c2)
-          r (+ r1 (* (- r2 r1) tr-offset))
-          g (+ g1 (* (- g2 g1) tr-offset))
-          b (+ b1 (* (- b2 b1) tr-offset))
-          a (+ a1 (* (- a2 a1) tr-offset))]
-      {:color (rgb->hex [r g b])
-       :opacity a
-       :r r
-       :g g
-       :b b
-       :alpha a
-       :offset offset})))
-
-(defn- offset-spread
-  [from to num]
-  (->> (range 0 num)
-       (map #(mth/precision (+ from (* (/ (- to from) (dec num)) %)) 2))))
-
-(defn uniform-spread?
-  "Checks if the gradient stops are spread uniformly"
-  [stops]
-  (let [cs          (count stops)
-        from        (first stops)
-        to          (last stops)
-        expect-vals (offset-spread (:offset from) (:offset to) cs)
-
-        calculate-expected
-        (fn [expected-offset stop]
-          (and (mth/close? (:offset stop) expected-offset)
-               (let [ec (interpolate-color from to expected-offset)]
-                 (and (= (:color ec) (:color stop))
-                      (= (:opacity ec) (:opacity stop))))))]
-    (->> (map calculate-expected expect-vals stops)
-         (every? true?))))
-
-(defn uniform-spread
-  "Assign an uniform spread to the offset values for the gradient"
-  [from to num-stops]
-  (->> (offset-spread (:offset from) (:offset to) num-stops)
-       (mapv (fn [offset]
-               (interpolate-color from to offset)))))
-
-(defn interpolate-gradient
-  [stops offset]
-  (let [idx   (d/index-of-pred stops #(<= offset (:offset %)))
-        start (if (= idx 0) (first stops) (get stops (dec idx)))
-        end   (if (nil? idx) (last stops) (get stops idx))]
-    (interpolate-color start end offset)))
diff --git a/common/test/common_tests/colors_test.cljc b/common/test/common_tests/colors_test.cljc
index aa1edd450a..21f6af5bef 100644
--- a/common/test/common_tests/colors_test.cljc
+++ b/common/test/common_tests/colors_test.cljc
@@ -387,44 +387,41 @@
   (t/is (= 0.25 (c/reduce-range 0.3 4)))
   (t/is (= 0.0  (c/reduce-range 0.0 10))))
 
-;; --- Gradient helpers
+;; --- Gradient helpers (app.common.types.color)
 
-(t/deftest ac-interpolate-color
-  (let [c1 {:color "#000000" :opacity 0.0 :offset 0.0}
-        c2 {:color "#ffffff" :opacity 1.0 :offset 1.0}]
-    ;; At c1's offset → c1 with updated offset
-    (let [result (c/interpolate-color c1 c2 0.0)]
+(t/deftest types-interpolate-color
+  (t/testing "at c1 offset returns c1 color"
+    (let [c1     {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2     {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          result (colors/interpolate-color c1 c2 0.0)]
       (t/is (= "#000000" (:color result)))
-      (t/is (= 0.0 (:opacity result))))
-    ;; At c2's offset → c2 with updated offset
-    (let [result (c/interpolate-color c1 c2 1.0)]
+      (t/is (= 0.0 (:opacity result)))))
+  (t/testing "at c2 offset returns c2 color"
+    (let [c1     {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2     {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          result (colors/interpolate-color c1 c2 1.0)]
       (t/is (= "#ffffff" (:color result)))
-      (t/is (= 1.0 (:opacity result))))
-    ;; At midpoint → gray
-    (let [result (c/interpolate-color c1 c2 0.5)]
+      (t/is (= 1.0 (:opacity result)))))
+  (t/testing "at midpoint returns interpolated gray"
+    (let [c1     {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2     {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          result (colors/interpolate-color c1 c2 0.5)]
       (t/is (= "#7f7f7f" (:color result)))
       (t/is (mth/close? (:opacity result) 0.5)))))
 
-(t/deftest ac-uniform-spread
-  (let [c1 {:color "#000000" :opacity 0.0 :offset 0.0}
-        c2 {:color "#ffffff" :opacity 1.0 :offset 1.0}
-        stops (c/uniform-spread c1 c2 3)]
-    (t/is (= 3 (count stops)))
-    (t/is (= 0.0 (:offset (first stops))))
-    (t/is (mth/close? 0.5 (:offset (second stops))))
-    (t/is (= 1.0 (:offset (last stops))))))
-
-(t/deftest ac-uniform-spread?
-  (let [c1 {:color "#000000" :opacity 0.0 :offset 0.0}
-        c2 {:color "#ffffff" :opacity 1.0 :offset 1.0}
-        stops (c/uniform-spread c1 c2 3)]
-    ;; A uniformly spread result should pass the predicate
-    (t/is (true? (c/uniform-spread? stops))))
-  ;; Manual non-uniform stops should not pass
-  (let [stops [{:color "#000000" :opacity 0.0 :offset 0.0}
-               {:color "#888888" :opacity 0.5 :offset 0.3}
-               {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
-    (t/is (false? (c/uniform-spread? stops)))))
+(t/deftest types-uniform-spread
+  (t/testing "produces correct count and offsets"
+    (let [c1    {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2    {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          stops (colors/uniform-spread c1 c2 3)]
+      (t/is (= 3 (count stops)))
+      (t/is (= 0.0 (:offset (first stops))))
+      (t/is (mth/close? 0.5 (:offset (second stops))))
+      (t/is (= 1.0 (:offset (last stops))))))
+  (t/testing "single stop returns a vector of one element (no division by zero)"
+    (let [c1    {:color "#ff0000" :opacity 1.0 :offset 0.0}
+          stops (colors/uniform-spread c1 c1 1)]
+      (t/is (= 1 (count stops))))))
 
 (t/deftest types-uniform-spread?
   (t/testing "uniformly spread stops are detected as uniform"
@@ -447,16 +444,25 @@
                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
       (t/is (false? (colors/uniform-spread? stops))))))
 
-(t/deftest ac-interpolate-gradient
-  (let [stops [{:color "#000000" :opacity 0.0 :offset 0.0}
-               {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
-    ;; At start
-    (let [result (c/interpolate-gradient stops 0.0)]
-      (t/is (= "#000000" (:color result))))
-    ;; At end
-    (let [result (c/interpolate-gradient stops 1.0)]
-      (t/is (= "#ffffff" (:color result))))
-    ;; In the middle
-    (let [result (c/interpolate-gradient stops 0.5)]
-      (t/is (= "#7f7f7f" (:color result))))))
+(t/deftest types-interpolate-gradient
+  (t/testing "at start offset returns first stop color"
+    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
+                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]
+          result (colors/interpolate-gradient stops 0.0)]
+      (t/is (= "#000000" (:color result)))))
+  (t/testing "at end offset returns last stop color"
+    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
+                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]
+          result (colors/interpolate-gradient stops 1.0)]
+      (t/is (= "#ffffff" (:color result)))))
+  (t/testing "at midpoint returns interpolated gray"
+    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
+                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]
+          result (colors/interpolate-gradient stops 0.5)]
+      (t/is (= "#7f7f7f" (:color result)))))
+  (t/testing "offset beyond last stop returns last stop color (nil idx guard)"
+    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
+                  {:color "#ffffff" :opacity 1.0 :offset 0.5}]
+          result (colors/interpolate-gradient stops 1.0)]
+      (t/is (= "#ffffff" (:color result))))))
 

From 6d1d0445884c21312aadc46fd3893e84b805d9a3 Mon Sep 17 00:00:00 2001
From: Andrey Antukh <niwi@niwi.nz>
Date: Tue, 14 Apr 2026 19:16:19 +0000
Subject: [PATCH 13/13] :recycle: Move app.common.types.color tests to their
 own namespace

Tests that exercise app.common.types.color were living inside
common-tests.colors-test alongside the app.common.colors tests. Move
them to common-tests.types.color-test so the test namespace mirrors
the source namespace structure, consistent with the rest of the
types/ test suite.

The [app.common.types.color :as colors] require is removed from
colors_test.cljc; the new file is registered in runner.cljc.

Signed-off-by: Andrey Antukh <niwi@niwi.nz>
---
 common/test/common_tests/colors_test.cljc     | 162 -----------------
 common/test/common_tests/runner.cljc          |   2 +
 .../test/common_tests/types/color_test.cljc   | 166 ++++++++++++++++++
 3 files changed, 168 insertions(+), 162 deletions(-)
 create mode 100644 common/test/common_tests/types/color_test.cljc

diff --git a/common/test/common_tests/colors_test.cljc b/common/test/common_tests/colors_test.cljc
index 21f6af5bef..7d6b0f0e3d 100644
--- a/common/test/common_tests/colors_test.cljc
+++ b/common/test/common_tests/colors_test.cljc
@@ -9,91 +9,8 @@
    #?(:cljs [goog.color :as gcolors])
    [app.common.colors :as c]
    [app.common.math :as mth]
-   [app.common.types.color :as colors]
    [clojure.test :as t]))
 
-(t/deftest valid-hex-color
-  (t/is (false? (colors/valid-hex-color? nil)))
-  (t/is (false? (colors/valid-hex-color? "")))
-  (t/is (false? (colors/valid-hex-color? "#")))
-  (t/is (false? (colors/valid-hex-color? "#qqqqqq")))
-  (t/is (true? (colors/valid-hex-color? "#aaa")))
-  (t/is (false? (colors/valid-hex-color? "#aaaa")))
-  (t/is (true? (colors/valid-hex-color? "#fabada"))))
-
-(t/deftest valid-rgb-color
-  (t/is (false? (colors/valid-rgb-color? nil)))
-  (t/is (false? (colors/valid-rgb-color? "")))
-  (t/is (false? (colors/valid-rgb-color? "()")))
-  (t/is (true? (colors/valid-rgb-color? "(255, 30, 30)")))
-  (t/is (true? (colors/valid-rgb-color? "rgb(255, 30, 30)"))))
-
-(t/deftest rgb-to-str
-  (t/is (= "rgb(1,2,3)" (colors/rgb->str [1 2 3])))
-  (t/is (= "rgba(1,2,3,4)" (colors/rgb->str [1 2 3 4]))))
-
-(t/deftest rgb-to-hsv
-  ;; (prn (colors/rgb->hsv [1 2 3]))
-  ;; (prn (gcolors/rgbToHsv 1 2 3))
-  (t/is (= [210.0 0.6666666666666666 3.0] (colors/rgb->hsv [1.0 2.0 3.0])))
-  #?(:cljs (t/is (= (colors/rgb->hsv [1 2 3]) (vec (gcolors/rgbToHsv 1 2 3))))))
-
-(t/deftest hsv-to-rgb
-  (t/is (= [1 2 3]
-           (colors/hsv->rgb [210 0.6666666666666666 3])))
-  #?(:cljs
-     (t/is (= (colors/hsv->rgb [210 0.6666666666666666 3])
-              (vec (gcolors/hsvToRgb 210 0.6666666666666666 3))))))
-
-(t/deftest rgb-to-hex
-  (t/is (= "#010203" (colors/rgb->hex [1 2 3]))))
-
-(t/deftest hex-to-rgb
-  (t/is (= [0 0 0] (colors/hex->rgb "#kkk")))
-  (t/is (= [1 2 3] (colors/hex->rgb "#010203"))))
-
-(t/deftest format-hsla
-  (t/is (= "210, 50%, 0.78%, 1" (colors/format-hsla [210.0 0.5 0.00784313725490196 1])))
-  (t/is (= "220, 5%, 30%, 0.8" (colors/format-hsla [220.0 0.05 0.3 0.8]))))
-
-(t/deftest format-rgba
-  (t/is (= "210, 199, 12, 0.08" (colors/format-rgba [210 199 12 0.08])))
-  (t/is (= "210, 199, 12, 1" (colors/format-rgba [210 199 12 1]))))
-
-(t/deftest rgb-to-hsl
-  (t/is (= [210.0 0.5 0.00784313725490196] (colors/rgb->hsl [1 2 3])))
-  #?(:cljs (t/is (= (colors/rgb->hsl [1 2 3])
-                    (vec (gcolors/rgbToHsl 1 2 3))))))
-
-(t/deftest hsl-to-rgb
-  (t/is (= [1 2 3] (colors/hsl->rgb [210.0 0.5 0.00784313725490196])))
-  (t/is (= [210.0 0.5 0.00784313725490196] (colors/rgb->hsl [1 2 3])))
-  #?(:cljs (t/is (= (colors/hsl->rgb [210 0.5 0.00784313725490196])
-                    (vec (gcolors/hslToRgb 210 0.5 0.00784313725490196))))))
-
-(t/deftest expand-hex
-  (t/is (= "aaaaaa" (colors/expand-hex "a")))
-  (t/is (= "aaaaaa" (colors/expand-hex "aa")))
-  (t/is (= "aaaaaa" (colors/expand-hex "aaa")))
-  (t/is (= "aaaa" (colors/expand-hex "aaaa"))))
-
-(t/deftest prepend-hash
-  (t/is "#aaa" (colors/prepend-hash "aaa"))
-  (t/is "#aaa" (colors/prepend-hash "#aaa")))
-
-(t/deftest remove-hash
-  (t/is "aaa" (colors/remove-hash "aaa"))
-  (t/is "aaa" (colors/remove-hash "#aaa")))
-
-(t/deftest color-string-pred
-  (t/is (true? (colors/color-string? "#aaa")))
-  (t/is (true? (colors/color-string? "(10,10,10)")))
-  (t/is (true? (colors/color-string? "rgb(10,10,10)")))
-  (t/is (true? (colors/color-string? "magenta")))
-  (t/is (false? (colors/color-string? nil)))
-  (t/is (false? (colors/color-string? "")))
-  (t/is (false? (colors/color-string? "kkkkkk"))))
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; app.common.colors tests
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -387,82 +304,3 @@
   (t/is (= 0.25 (c/reduce-range 0.3 4)))
   (t/is (= 0.0  (c/reduce-range 0.0 10))))
 
-;; --- Gradient helpers (app.common.types.color)
-
-(t/deftest types-interpolate-color
-  (t/testing "at c1 offset returns c1 color"
-    (let [c1     {:color "#000000" :opacity 0.0 :offset 0.0}
-          c2     {:color "#ffffff" :opacity 1.0 :offset 1.0}
-          result (colors/interpolate-color c1 c2 0.0)]
-      (t/is (= "#000000" (:color result)))
-      (t/is (= 0.0 (:opacity result)))))
-  (t/testing "at c2 offset returns c2 color"
-    (let [c1     {:color "#000000" :opacity 0.0 :offset 0.0}
-          c2     {:color "#ffffff" :opacity 1.0 :offset 1.0}
-          result (colors/interpolate-color c1 c2 1.0)]
-      (t/is (= "#ffffff" (:color result)))
-      (t/is (= 1.0 (:opacity result)))))
-  (t/testing "at midpoint returns interpolated gray"
-    (let [c1     {:color "#000000" :opacity 0.0 :offset 0.0}
-          c2     {:color "#ffffff" :opacity 1.0 :offset 1.0}
-          result (colors/interpolate-color c1 c2 0.5)]
-      (t/is (= "#7f7f7f" (:color result)))
-      (t/is (mth/close? (:opacity result) 0.5)))))
-
-(t/deftest types-uniform-spread
-  (t/testing "produces correct count and offsets"
-    (let [c1    {:color "#000000" :opacity 0.0 :offset 0.0}
-          c2    {:color "#ffffff" :opacity 1.0 :offset 1.0}
-          stops (colors/uniform-spread c1 c2 3)]
-      (t/is (= 3 (count stops)))
-      (t/is (= 0.0 (:offset (first stops))))
-      (t/is (mth/close? 0.5 (:offset (second stops))))
-      (t/is (= 1.0 (:offset (last stops))))))
-  (t/testing "single stop returns a vector of one element (no division by zero)"
-    (let [c1    {:color "#ff0000" :opacity 1.0 :offset 0.0}
-          stops (colors/uniform-spread c1 c1 1)]
-      (t/is (= 1 (count stops))))))
-
-(t/deftest types-uniform-spread?
-  (t/testing "uniformly spread stops are detected as uniform"
-    (let [c1    {:color "#000000" :opacity 0.0 :offset 0.0}
-          c2    {:color "#ffffff" :opacity 1.0 :offset 1.0}
-          stops (colors/uniform-spread c1 c2 3)]
-      (t/is (true? (colors/uniform-spread? stops)))))
-  (t/testing "two-stop gradient is uniform by definition"
-    (let [stops [{:color "#ff0000" :opacity 1.0 :offset 0.0}
-                 {:color "#0000ff" :opacity 1.0 :offset 1.0}]]
-      (t/is (true? (colors/uniform-spread? stops)))))
-  (t/testing "stops with wrong offset are not uniform"
-    (let [stops [{:color "#000000" :opacity 0.0 :offset 0.0}
-                 {:color "#888888" :opacity 0.5 :offset 0.3}
-                 {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
-      (t/is (false? (colors/uniform-spread? stops)))))
-  (t/testing "stops with correct offset but wrong color are not uniform"
-    (let [stops [{:color "#000000" :opacity 0.0 :offset 0.0}
-                 {:color "#aaaaaa" :opacity 0.5 :offset 0.5}
-                 {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
-      (t/is (false? (colors/uniform-spread? stops))))))
-
-(t/deftest types-interpolate-gradient
-  (t/testing "at start offset returns first stop color"
-    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
-                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]
-          result (colors/interpolate-gradient stops 0.0)]
-      (t/is (= "#000000" (:color result)))))
-  (t/testing "at end offset returns last stop color"
-    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
-                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]
-          result (colors/interpolate-gradient stops 1.0)]
-      (t/is (= "#ffffff" (:color result)))))
-  (t/testing "at midpoint returns interpolated gray"
-    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
-                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]
-          result (colors/interpolate-gradient stops 0.5)]
-      (t/is (= "#7f7f7f" (:color result)))))
-  (t/testing "offset beyond last stop returns last stop color (nil idx guard)"
-    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
-                  {:color "#ffffff" :opacity 1.0 :offset 0.5}]
-          result (colors/interpolate-gradient stops 1.0)]
-      (t/is (= "#ffffff" (:color result))))))
-
diff --git a/common/test/common_tests/runner.cljc b/common/test/common_tests/runner.cljc
index 6df8243077..2d9a216cbc 100644
--- a/common/test/common_tests/runner.cljc
+++ b/common/test/common_tests/runner.cljc
@@ -54,6 +54,7 @@
    [common-tests.text-test]
    [common-tests.time-test]
    [common-tests.types.absorb-assets-test]
+   [common-tests.types.color-test]
    [common-tests.types.components-test]
    [common-tests.types.container-test]
    [common-tests.types.fill-test]
@@ -126,6 +127,7 @@
    'common-tests.text-test
    'common-tests.time-test
    'common-tests.types.absorb-assets-test
+   'common-tests.types.color-test
    'common-tests.types.components-test
    'common-tests.types.container-test
    'common-tests.types.fill-test
diff --git a/common/test/common_tests/types/color_test.cljc b/common/test/common_tests/types/color_test.cljc
new file mode 100644
index 0000000000..9a3ab00ac9
--- /dev/null
+++ b/common/test/common_tests/types/color_test.cljc
@@ -0,0 +1,166 @@
+;; This Source Code Form is subject to the terms of the Mozilla Public
+;; License, v. 2.0. If a copy of the MPL was not distributed with this
+;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
+;;
+;; Copyright (c) KALEIDOS INC
+
+(ns common-tests.types.color-test
+  (:require
+   [app.common.math :as mth]
+   [app.common.types.color :as colors]
+   [clojure.test :as t]))
+
+;; --- Predicates
+
+(t/deftest valid-hex-color
+  (t/is (false? (colors/valid-hex-color? nil)))
+  (t/is (false? (colors/valid-hex-color? "")))
+  (t/is (false? (colors/valid-hex-color? "#")))
+  (t/is (false? (colors/valid-hex-color? "#qqqqqq")))
+  (t/is (true? (colors/valid-hex-color? "#aaa")))
+  (t/is (false? (colors/valid-hex-color? "#aaaa")))
+  (t/is (true? (colors/valid-hex-color? "#fabada"))))
+
+(t/deftest valid-rgb-color
+  (t/is (false? (colors/valid-rgb-color? nil)))
+  (t/is (false? (colors/valid-rgb-color? "")))
+  (t/is (false? (colors/valid-rgb-color? "()")))
+  (t/is (true? (colors/valid-rgb-color? "(255, 30, 30)")))
+  (t/is (true? (colors/valid-rgb-color? "rgb(255, 30, 30)"))))
+
+;; --- Conversions
+
+(t/deftest rgb-to-str
+  (t/is (= "rgb(1,2,3)" (colors/rgb->str [1 2 3])))
+  (t/is (= "rgba(1,2,3,4)" (colors/rgb->str [1 2 3 4]))))
+
+(t/deftest rgb-to-hsv
+  (t/is (= [210.0 0.6666666666666666 3.0] (colors/rgb->hsv [1.0 2.0 3.0]))))
+
+(t/deftest hsv-to-rgb
+  (t/is (= [1 2 3]
+           (colors/hsv->rgb [210 0.6666666666666666 3]))))
+
+(t/deftest rgb-to-hex
+  (t/is (= "#010203" (colors/rgb->hex [1 2 3]))))
+
+(t/deftest hex-to-rgb
+  (t/is (= [0 0 0] (colors/hex->rgb "#kkk")))
+  (t/is (= [1 2 3] (colors/hex->rgb "#010203"))))
+
+(t/deftest format-hsla
+  (t/is (= "210, 50%, 0.78%, 1" (colors/format-hsla [210.0 0.5 0.00784313725490196 1])))
+  (t/is (= "220, 5%, 30%, 0.8" (colors/format-hsla [220.0 0.05 0.3 0.8]))))
+
+(t/deftest format-rgba
+  (t/is (= "210, 199, 12, 0.08" (colors/format-rgba [210 199 12 0.08])))
+  (t/is (= "210, 199, 12, 1" (colors/format-rgba [210 199 12 1]))))
+
+(t/deftest rgb-to-hsl
+  (t/is (= [210.0 0.5 0.00784313725490196] (colors/rgb->hsl [1 2 3]))))
+
+(t/deftest hsl-to-rgb
+  (t/is (= [1 2 3] (colors/hsl->rgb [210.0 0.5 0.00784313725490196])))
+  (t/is (= [210.0 0.5 0.00784313725490196] (colors/rgb->hsl [1 2 3]))))
+
+(t/deftest expand-hex
+  (t/is (= "aaaaaa" (colors/expand-hex "a")))
+  (t/is (= "aaaaaa" (colors/expand-hex "aa")))
+  (t/is (= "aaaaaa" (colors/expand-hex "aaa")))
+  (t/is (= "aaaa" (colors/expand-hex "aaaa"))))
+
+(t/deftest prepend-hash
+  (t/is "#aaa" (colors/prepend-hash "aaa"))
+  (t/is "#aaa" (colors/prepend-hash "#aaa")))
+
+(t/deftest remove-hash
+  (t/is "aaa" (colors/remove-hash "aaa"))
+  (t/is "aaa" (colors/remove-hash "#aaa")))
+
+(t/deftest color-string-pred
+  (t/is (true? (colors/color-string? "#aaa")))
+  (t/is (true? (colors/color-string? "(10,10,10)")))
+  (t/is (true? (colors/color-string? "rgb(10,10,10)")))
+  (t/is (true? (colors/color-string? "magenta")))
+  (t/is (false? (colors/color-string? nil)))
+  (t/is (false? (colors/color-string? "")))
+  (t/is (false? (colors/color-string? "kkkkkk"))))
+
+;; --- Gradient helpers
+
+(t/deftest interpolate-color
+  (t/testing "at c1 offset returns c1 color"
+    (let [c1     {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2     {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          result (colors/interpolate-color c1 c2 0.0)]
+      (t/is (= "#000000" (:color result)))
+      (t/is (= 0.0 (:opacity result)))))
+  (t/testing "at c2 offset returns c2 color"
+    (let [c1     {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2     {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          result (colors/interpolate-color c1 c2 1.0)]
+      (t/is (= "#ffffff" (:color result)))
+      (t/is (= 1.0 (:opacity result)))))
+  (t/testing "at midpoint returns interpolated gray"
+    (let [c1     {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2     {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          result (colors/interpolate-color c1 c2 0.5)]
+      (t/is (= "#7f7f7f" (:color result)))
+      (t/is (mth/close? (:opacity result) 0.5)))))
+
+(t/deftest uniform-spread
+  (t/testing "produces correct count and offsets"
+    (let [c1    {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2    {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          stops (colors/uniform-spread c1 c2 3)]
+      (t/is (= 3 (count stops)))
+      (t/is (= 0.0 (:offset (first stops))))
+      (t/is (mth/close? 0.5 (:offset (second stops))))
+      (t/is (= 1.0 (:offset (last stops))))))
+  (t/testing "single stop returns a vector of one element (no division by zero)"
+    (let [c1    {:color "#ff0000" :opacity 1.0 :offset 0.0}
+          stops (colors/uniform-spread c1 c1 1)]
+      (t/is (= 1 (count stops))))))
+
+(t/deftest uniform-spread?
+  (t/testing "uniformly spread stops are detected as uniform"
+    (let [c1    {:color "#000000" :opacity 0.0 :offset 0.0}
+          c2    {:color "#ffffff" :opacity 1.0 :offset 1.0}
+          stops (colors/uniform-spread c1 c2 3)]
+      (t/is (true? (colors/uniform-spread? stops)))))
+  (t/testing "two-stop gradient is uniform by definition"
+    (let [stops [{:color "#ff0000" :opacity 1.0 :offset 0.0}
+                 {:color "#0000ff" :opacity 1.0 :offset 1.0}]]
+      (t/is (true? (colors/uniform-spread? stops)))))
+  (t/testing "stops with wrong offset are not uniform"
+    (let [stops [{:color "#000000" :opacity 0.0 :offset 0.0}
+                 {:color "#888888" :opacity 0.5 :offset 0.3}
+                 {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
+      (t/is (false? (colors/uniform-spread? stops)))))
+  (t/testing "stops with correct offset but wrong color are not uniform"
+    (let [stops [{:color "#000000" :opacity 0.0 :offset 0.0}
+                 {:color "#aaaaaa" :opacity 0.5 :offset 0.5}
+                 {:color "#ffffff" :opacity 1.0 :offset 1.0}]]
+      (t/is (false? (colors/uniform-spread? stops))))))
+
+(t/deftest interpolate-gradient
+  (t/testing "at start offset returns first stop color"
+    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
+                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]
+          result (colors/interpolate-gradient stops 0.0)]
+      (t/is (= "#000000" (:color result)))))
+  (t/testing "at end offset returns last stop color"
+    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
+                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]
+          result (colors/interpolate-gradient stops 1.0)]
+      (t/is (= "#ffffff" (:color result)))))
+  (t/testing "at midpoint returns interpolated gray"
+    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
+                  {:color "#ffffff" :opacity 1.0 :offset 1.0}]
+          result (colors/interpolate-gradient stops 0.5)]
+      (t/is (= "#7f7f7f" (:color result)))))
+  (t/testing "offset beyond last stop returns last stop color (nil idx guard)"
+    (let [stops  [{:color "#000000" :opacity 0.0 :offset 0.0}
+                  {:color "#ffffff" :opacity 1.0 :offset 0.5}]
+          result (colors/interpolate-gradient stops 1.0)]
+      (t/is (= "#ffffff" (:color result))))))