fix(theme): make accent candidates immutable

commit: 6e468caf18d4a81db95bb2af75ac0043d6f2f3bd
author: brice · 3mo ago · 2026-07-18 08:14 UTC
parent: ffd16e4
signature: GPG VerifiedCD88F9E564E0102646FB6077A1A07C7C7C3E349D · arch-gpg Verified for the committer email

2 files · +37 -21

M internal/usecase/theme/accent_resolve.go +29 -20


@@ -22,9 +22,16 @@ type Accent struct {
22	22		}
23	23
24	24		// The resolver only ever considers the chromatic ANSI slots in automatic
25		-	// mode. Keeping this as a fixed array makes resolution bounded and independent
26		-	// of terminal response order.
27		-	var accentCandidateSlots = [...]uint8{1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14}
	25	+	// mode. This immutable mapping keeps resolution bounded and independent of
	26	+	// terminal response order without mutable package-level state.
	27	+	const accentCandidateCount = 12
	28	+
	29	+	func accentCandidateSlot(index int) uint8 {
	30	+	if index < 6 {
	31	+	return uint8(index + 1)
	32	+	}
	33	+	return uint8(index + 3)
	34	+	}
28	35
29	36		type accentGroup struct {
30	37		members uint16

@@ -64,10 +71,11 @@ func resolveAutoAccent(t Theme) Accent {
64	71		return schemeIndexedBlue(t)
65	72		}
66	73
67		-	var colors [len(accentCandidateSlots)]oklab
	74	+	var colors [accentCandidateCount]oklab
68	75		var eligible uint16
69	76		background := rgbToOKLab(t.Background)
70		-	for i, slot := range accentCandidateSlots {
	77	+	for i := range accentCandidateCount {
	78	+	slot := accentCandidateSlot(i)
71	79		if t.PaletteKnown&(uint16(1)<<slot) == 0 {
72	80		continue
73	81		}

@@ -80,13 +88,13 @@ func resolveAutoAccent(t Theme) Accent {
80	88		return fallbackAutoAccent(t, background)
81	89		}
82	90
83		-	var adjacent [len(accentCandidateSlots)]uint16
84		-	for i := range accentCandidateSlots {
	91	+	var adjacent [accentCandidateCount]uint16
	92	+	for i := range accentCandidateCount {
85	93		if eligible&(uint16(1)<<i) == 0 {
86	94		continue
87	95		}
88	96		adjacent[i] = uint16(1) << i
89		-	for j := i + 1; j < len(accentCandidateSlots); j++ {
	97	+	for j := i + 1; j < accentCandidateCount; j++ {
90	98		if eligible&(uint16(1)<<j) == 0 \|\| !accentConnected(colors[i], colors[j]) {
91	99		continue
92	100		}

@@ -95,15 +103,15 @@ func resolveAutoAccent(t Theme) Accent {
95	103		}
96	104		}
97	105
98		-	var groups [len(accentCandidateSlots)]accentGroup
	106	+	var groups [accentCandidateCount]accentGroup
99	107		var visited uint16
100	108		groupCount := 0
101		-	for start := range accentCandidateSlots {
	109	+	for start := range accentCandidateCount {
102	110		startBit := uint16(1) << start
103	111		if eligible&startBit == 0 \|\| visited&startBit != 0 {
104	112		continue
105	113		}
106		-	var queue [len(accentCandidateSlots)]uint8
	114	+	var queue [accentCandidateCount]uint8
107	115		head, tail := 0, 1
108	116		queue[0] = uint8(start)
109	117		visited \|= startBit

@@ -112,7 +120,7 @@ func resolveAutoAccent(t Theme) Accent {
112	120		head++
113	121		groups[groupCount].members \|= uint16(1) << i
114	122		neighbors := adjacent[i] &^ visited
115		-	for j := range accentCandidateSlots {
	123	+	for j := range accentCandidateCount {
116	124		bit := uint16(1) << j
117	125		if neighbors&bit == 0 {
118	126		continue

@@ -141,7 +149,7 @@ func resolveAutoAccent(t Theme) Accent {
141	149		runnerSize, runnerPairs = groups[runner].size, groups[runner].pairs
142	150		}
143	151		if winner.size >= 2 && (winner.size > runnerSize \|\| winner.pairs > runnerPairs) {
144		-	slot := accentCandidateSlots[winner.rep]
	152	+	slot := accentCandidateSlot(int(winner.rep))
145	153		return resolvedAccent(t, t.Palette[slot], slot)
146	154		}
147	155

@@ -180,23 +188,24 @@ func indexedAccent(slot uint8) Accent {
180	188		return Accent{Slot: slot, IndexedOnly: true}
181	189		}
182	190
183		-	func finalizeAccentGroup(group *accentGroup, colors [len(accentCandidateSlots)]oklab) {
	191	+	func finalizeAccentGroup(group *accentGroup, colors [accentCandidateCount]oklab) {
184	192		var representative uint8
185	193		var representativeDistance float64
186	194		first := true
187		-	for i, slot := range accentCandidateSlots {
	195	+	for i := range accentCandidateCount {
	196	+	slot := accentCandidateSlot(i)
188	197		if group.members&(uint16(1)<<i) == 0 {
189	198		continue
190	199		}
191	200		group.size++
192	201		group.chromaSum += okLabChroma(colors[i])
193	202		var totalDistance float64
194		-	for j := range accentCandidateSlots {
	203	+	for j := range accentCandidateCount {
195	204		if group.members&(uint16(1)<<j) != 0 {
196	205		totalDistance += okLabDistance(colors[i], colors[j])
197	206		}
198	207		}
199		-	if first \|\| totalDistance < representativeDistance \|\| (totalDistance == representativeDistance && slot < accentCandidateSlots[representative]) {
	208	+	if first \|\| totalDistance < representativeDistance \|\| (totalDistance == representativeDistance && slot < accentCandidateSlot(int(representative))) {
200	209		first = false
201	210		representative = uint8(i)
202	211		representativeDistance = totalDistance

@@ -211,8 +220,8 @@ func finalizeAccentGroup(group *accentGroup, colors [len(accentCandidateSlots)]o
211	220		}
212	221
213	222		func accentGroupHasSlot(group accentGroup, slot uint8) bool {
214		-	for i, candidate := range accentCandidateSlots {
215		-	if candidate == slot {
	223	+	for i := range accentCandidateCount {
	224	+	if accentCandidateSlot(i) == slot {
216	225		return group.members&(uint16(1)<<i) != 0
217	226		}
218	227		}

@@ -236,7 +245,7 @@ func betterAccentGroup(a, b accentGroup) bool {
236	245		if aBlue != bBlue {
237	246		return aBlue
238	247		}
239		-	return accentCandidateSlots[a.rep] < accentCandidateSlots[b.rep]
	248	+	return accentCandidateSlot(int(a.rep)) < accentCandidateSlot(int(b.rep))
240	249		}
241	250
242	251		func resolvedAccent(t Theme, color renderer.RGB, slot uint8) Accent {

 }
 // The resolver only ever considers the chromatic ANSI slots in automatic
-// mode. Keeping this as a fixed array makes resolution bounded and independent
+// mode. This immutable mapping keeps resolution bounded and independent of
-// of terminal response order.
+// terminal response order without mutable package-level state.
-var accentCandidateSlots = [...]uint8{1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14}
+const accentCandidateCount = 12
+func accentCandidateSlot(index int) uint8 {
+	if index < 6 {
+		return uint8(index + 1)
+	}
+	return uint8(index + 3)
+}
 type accentGroup struct {
 	members   uint16
 		return schemeIndexedBlue(t)
 	}
-	var colors [len(accentCandidateSlots)]oklab
+	var colors [accentCandidateCount]oklab
 	var eligible uint16
 	background := rgbToOKLab(t.Background)
-	for i, slot := range accentCandidateSlots {
+	for i := range accentCandidateCount {
+		slot := accentCandidateSlot(i)
 		if t.PaletteKnown&(uint16(1)<<slot) == 0 {
 			continue
 		}
 		return fallbackAutoAccent(t, background)
 	}
-	var adjacent [len(accentCandidateSlots)]uint16
+	var adjacent [accentCandidateCount]uint16
-	for i := range accentCandidateSlots {
+	for i := range accentCandidateCount {
 		if eligible&(uint16(1)<<i) == 0 {
 			continue
 		}
 		adjacent[i] = uint16(1) << i
-		for j := i + 1; j < len(accentCandidateSlots); j++ {
+		for j := i + 1; j < accentCandidateCount; j++ {
 			if eligible&(uint16(1)<<j) == 0 || !accentConnected(colors[i], colors[j]) {
 				continue
 			}
 		}
 	}
-	var groups [len(accentCandidateSlots)]accentGroup
+	var groups [accentCandidateCount]accentGroup
 	var visited uint16
 	groupCount := 0
-	for start := range accentCandidateSlots {
+	for start := range accentCandidateCount {
 		startBit := uint16(1) << start
 		if eligible&startBit == 0 || visited&startBit != 0 {
 			continue
 		}
-		var queue [len(accentCandidateSlots)]uint8
+		var queue [accentCandidateCount]uint8
 		head, tail := 0, 1
 		queue[0] = uint8(start)
 		visited |= startBit
 			head++
 			groups[groupCount].members |= uint16(1) << i
 			neighbors := adjacent[i] &^ visited
-			for j := range accentCandidateSlots {
+			for j := range accentCandidateCount {
 				bit := uint16(1) << j
 				if neighbors&bit == 0 {
 					continue
 		runnerSize, runnerPairs = groups[runner].size, groups[runner].pairs
 	}
 	if winner.size >= 2 && (winner.size > runnerSize || winner.pairs > runnerPairs) {
-		slot := accentCandidateSlots[winner.rep]
+		slot := accentCandidateSlot(int(winner.rep))
 		return resolvedAccent(t, t.Palette[slot], slot)
 	}
 	return Accent{Slot: slot, IndexedOnly: true}
 }
-func finalizeAccentGroup(group *accentGroup, colors [len(accentCandidateSlots)]oklab) {
+func finalizeAccentGroup(group *accentGroup, colors [accentCandidateCount]oklab) {
 	var representative uint8
 	var representativeDistance float64
 	first := true
-	for i, slot := range accentCandidateSlots {
+	for i := range accentCandidateCount {
+		slot := accentCandidateSlot(i)
 		if group.members&(uint16(1)<<i) == 0 {
 			continue
 		}
 		group.size++
 		group.chromaSum += okLabChroma(colors[i])
 		var totalDistance float64
-		for j := range accentCandidateSlots {
+		for j := range accentCandidateCount {
 			if group.members&(uint16(1)<<j) != 0 {
 				totalDistance += okLabDistance(colors[i], colors[j])
 			}
 		}
-		if first || totalDistance < representativeDistance || (totalDistance == representativeDistance && slot < accentCandidateSlots[representative]) {
+		if first || totalDistance < representativeDistance || (totalDistance == representativeDistance && slot < accentCandidateSlot(int(representative))) {
 			first = false
 			representative = uint8(i)
 			representativeDistance = totalDistance
 }
 func accentGroupHasSlot(group accentGroup, slot uint8) bool {
-	for i, candidate := range accentCandidateSlots {
+	for i := range accentCandidateCount {
-		if candidate == slot {
+		if accentCandidateSlot(i) == slot {
 			return group.members&(uint16(1)<<i) != 0
 		}
 	}
 	if aBlue != bBlue {
 		return aBlue
 	}
-	return accentCandidateSlots[a.rep] < accentCandidateSlots[b.rep]
+	return accentCandidateSlot(int(a.rep)) < accentCandidateSlot(int(b.rep))
 }
 func resolvedAccent(t Theme, color renderer.RGB, slot uint8) Accent {

M internal/usecase/theme/accent_resolve_test.go +8 -1


@@ -9,6 +9,13 @@ import (
9	9		"github.com/stretchr/testify/require"
10	10		)
11	11
	12	+	func TestAccentCandidateSlotsAreFixedAndAscending(t *testing.T) {
	13	+	want := [...]uint8{1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14}
	14	+	for i, slot := range want {
	15	+	require.Equalf(t, slot, accentCandidateSlot(i), "candidate index %d", i)
	16	+	}
	17	+	}
	18	+
12	19		func TestResolveAccentThresholds(t *testing.T) {
13	20		tests := []struct {
14	21		name string

@@ -193,7 +200,7 @@ func TestResolveAccentDeterministicAcrossShuffledPaletteConstruction(t *testing.
193	200
194	201		func TestResolveAccentMedoidAndTieBreak(t *testing.T) {
195	202		group := accentGroup{members: 1<<0 \| 1<<1 \| 1<<2}
196		-	colors := [len(accentCandidateSlots)]oklab{
	203	+	colors := [accentCandidateCount]oklab{
197	204		{L: 0.10, A: 0.10}, {L: 0.11, A: 0.10}, {L: 0.12, A: 0.10},
198	205		}
199	206		finalizeAccentGroup(&group, colors)

 	"github.com/stretchr/testify/require"
 )
+func TestAccentCandidateSlotsAreFixedAndAscending(t *testing.T) {
+	want := [...]uint8{1, 2, 3, 4, 5, 6, 9, 10, 11, 12, 13, 14}
+	for i, slot := range want {
+		require.Equalf(t, slot, accentCandidateSlot(i), "candidate index %d", i)
+	}
+}
 func TestResolveAccentThresholds(t *testing.T) {
 	tests := []struct {
 		name       string
 func TestResolveAccentMedoidAndTieBreak(t *testing.T) {
 	group := accentGroup{members: 1<<0 | 1<<1 | 1<<2}
-	colors := [len(accentCandidateSlots)]oklab{
+	colors := [accentCandidateCount]oklab{
 		{L: 0.10, A: 0.10}, {L: 0.11, A: 0.10}, {L: 0.12, A: 0.10},
 	}
 	finalizeAccentGroup(&group, colors)