fix: place user overrides first in deconfliction + add comprehensive tests

Fix a bug where a hash-based run sorting before a user-overridden run
would not be deconflicted against the user's explicit color choice.

The algorithm now has three phases:
- Phase 0: Place ALL user-overridden colors as immovable landmarks first,
  regardless of sort position.  This ensures every hash-based run is
  always checked against every user-chosen color.
- Phase 1: Place cached non-user runs (preserving their deconflictions).
- Phase 2: Process remaining new non-user runs against the full set.

Add comprehensive test suite (oklch_colors_test.ts) covering:
- Basic: no runs, single run, distant colors (no deconfliction)
- Clash detection: identical colors, very similar colors, multiple clashes
- User overrides: never deconflicted, respected as landmarks, hash runs
  checked against user colors regardless of sort order
- Mixed scenarios: user override in middle, user override sorting later
- Replacement quality: 3-axis search verified, sRGB-valid output
- Incremental/cache: cached runs preserved, new runs checked against all
- Determinism: same inputs → same outputs, Map insertion order independent
- Dark mode: different lightness ranges
- Stress: 30 identical runs, realistic 12-run scenario

Co-authored-by: Samuel <samuel@knutsen.co>

Author: cursoragent

tensorbored/webapp/util/BUILD

@@ -110,6 +110,7 @@ tf_ts_library(
         "matcher_test.ts",
         "memoize_test.ts",
         "ngrx_test.ts",
+        "oklch_colors_test.ts",
         "string_test.ts",
         "ui_selectors_test.ts",
         "value_formatter_test.ts",
@@ -121,6 +122,7 @@ tf_ts_library(
         ":matcher",
         ":memoize",
         ":ngrx",
+        ":oklch_colors",
         ":string",
         ":ui_selectors",
         ":value_formatter",

tensorbored/webapp/util/oklch_colors.ts

@@ -332,32 +332,45 @@ export function computeDeconfliction(
   const deconflictions = new Map<string, string>();
   const assignedColors: string[] = [];
   const assignedLabs: Lab[] = [];
+  const placed = new Set<string>();
 
-  // Phase 1: Collect effective colors for all cached runs (preserving order).
+  function placeColor(hex: string) {
+    assignedColors.push(hex);
+    assignedLabs.push(hexToOklab(hex));
+  }
+
+  // Phase 0: Place all user-overridden colors as immovable landmarks.
+  // These go first regardless of sort position so that every hash-based
+  // run is always checked against every user-chosen color.
+  for (const runId of sortedRunIds) {
+    if (!userOverriddenRuns.has(runId)) continue;
+    placeColor(runIdToBaseColor.get(runId)!);
+    placed.add(runId);
+  }
+
+  // Phase 1: Place cached non-user runs (preserving their deconflictions).
   for (const runId of sortedRunIds) {
-    if (!cachedRunIds.has(runId)) continue;
+    if (placed.has(runId) || !cachedRunIds.has(runId)) continue;
 
-    const baseColor = runIdToBaseColor.get(runId)!;
     const cached = cachedDeconflictions.get(runId);
-    const effective = cached ?? baseColor;
+    const effective = cached ?? runIdToBaseColor.get(runId)!;
 
     if (cached) {
       deconflictions.set(runId, cached);
     }
-    assignedColors.push(effective);
-    assignedLabs.push(hexToOklab(effective));
+    placeColor(effective);
+    placed.add(runId);
   }
 
-  // Phase 2: Process new runs against all cached + previously-deconflicted colors.
+  // Phase 2: Process remaining (new, non-user) runs.
   for (const runId of sortedRunIds) {
-    if (cachedRunIds.has(runId)) continue;
+    if (placed.has(runId)) continue;
 
     const baseColor = runIdToBaseColor.get(runId)!;
     const baseLab = hexToOklab(baseColor);
 
-    if (assignedLabs.length === 0 || userOverriddenRuns.has(runId)) {
-      assignedColors.push(baseColor);
-      assignedLabs.push(baseLab);
+    if (assignedLabs.length === 0) {
+      placeColor(baseColor);
       continue;
     }
 
@@ -368,17 +381,14 @@ export function computeDeconfliction(
     }
 
     if (minDist >= MIN_DELTA_E) {
-      assignedColors.push(baseColor);
-      assignedLabs.push(baseLab);
+      placeColor(baseColor);
     } else {
       const replacement = findDistantColor(assignedColors, darkMode);
       if (replacement) {
         deconflictions.set(runId, replacement);
-        assignedColors.push(replacement);
-        assignedLabs.push(hexToOklab(replacement));
+        placeColor(replacement);
       } else {
-        assignedColors.push(baseColor);
-        assignedLabs.push(baseLab);
+        placeColor(baseColor);
       }
     }
   }