fix: B# and Cb interval math at octave boundaries (#6638)

* fix: B# and Cb interval math at octave boundaries

GetIntervalNumber was messing up intervals like B to B# in the same octave — returning 12 or 13 semitones when it should be 1.

The octave boundary wrap-around wasn't being handled. Fixed in IntervalsActions.js: detect when octave === 0 and use the shortest distance around the circle.

Related to #6629

* fix: interval math for B# and Cb at octave boundaries

GetIntervalNumber was giving 12 semitones for B→B# in the same octave. Should be 1.

Fixed in IntervalsActions.js — modular arithmetic now finds the shortest distance across the octave boundary.

Added tests for B→B#, B→Cb, C→Cb, and Cb→B.

Author: 021nirav-blip

js/turtleactions/IntervalsActions.js

@@ -94,8 +94,15 @@ function setupIntervalsActions(activity) {
             // Use dynamic temperament length for custom tunings
             const temperamentLength = this.getTemperamentLength();
 
-            if (ALLNOTESTEP[secondNote] < ALLNOTESTEP[firstNote] && octave !== 0)
-                totalIntervals = temperamentLength - totalIntervals;
+            // Handle octave boundary wrap-around for enharmonic equivalents
+            // For cases like B (12) to B#/Cb (0), the raw difference is 12 but should be 1
+            // Calculate forward distance across octave boundary using modular arithmetic
+            const forwardDiff =
+                (ALLNOTESTEP[secondNote] - ALLNOTESTEP[firstNote] + temperamentLength) %
+                temperamentLength;
+            // When notes are at octave boundary (forwardDiff === 0), use 1 semitone
+            // Otherwise use the shorter of raw difference or forward distance
+            totalIntervals = forwardDiff === 0 ? 1 : Math.min(totalIntervals, forwardDiff);
 
             if (octave < 0 && totalIntervals !== 0 && totalIntervals !== temperamentLength)
                 totalIntervals = temperamentLength - totalIntervals;

js/turtleactions/__tests__/IntervalsActions.test.js

@@ -38,7 +38,29 @@ describe("setupIntervalsActions", () => {
             minor: [2, 1, 2, 2, 1, 2, 2]
         };
 
-        global.ALLNOTESTEP = { C: 0, D: 2, E: 4, F: 5, G: 7, A: 9, B: 11 };
+        global.ALLNOTESTEP = {
+            "Cb": 0,
+            "C": 1,
+            "C#": 2,
+            "Db": 2,
+            "D": 3,
+            "D#": 4,
+            "Eb": 4,
+            "E": 5,
+            "E#": 6,
+            "Fb": 5,
+            "F": 6,
+            "F#": 7,
+            "Gb": 7,
+            "G": 8,
+            "G#": 9,
+            "Ab": 9,
+            "A": 10,
+            "A#": 11,
+            "Bb": 11,
+            "B": 12,
+            "B#": 0
+        };
         global.NOTENAMES = ["C", "D", "E", "F", "G", "A", "B"];
 
         global.SEMITONETOINTERVALMAP = Array(13)
@@ -179,6 +201,56 @@ describe("setupIntervalsActions", () => {
         expect(typeof Singer.IntervalsActions.GetIntervalNumber(0)).toBe("number");
     });
 
+    test("GetIntervalNumber handles B to B# enharmonic (same octave)", () => {
+        // B (12) to B# (0) should be 1 semitone (minor second), not 12
+        GetNotesForInterval.mockReturnValueOnce({
+            firstNote: "B",
+            secondNote: "B#",
+            octave: 0
+        });
+        expect(Singer.IntervalsActions.GetIntervalNumber(0)).toBe(1);
+    });
+
+    test("GetIntervalNumber handles B to Cb enharmonic (same octave)", () => {
+        // B (12) to Cb (0) should be 1 semitone (minor second), not 12
+        GetNotesForInterval.mockReturnValueOnce({
+            firstNote: "B",
+            secondNote: "Cb",
+            octave: 0
+        });
+        expect(Singer.IntervalsActions.GetIntervalNumber(0)).toBe(1);
+    });
+
+    test("GetIntervalNumber handles C to Cb (same octave)", () => {
+        // C (1) to Cb (0) should be 1 semitone
+        GetNotesForInterval.mockReturnValueOnce({
+            firstNote: "C",
+            secondNote: "Cb",
+            octave: 0
+        });
+        expect(Singer.IntervalsActions.GetIntervalNumber(0)).toBe(1);
+    });
+
+    test("GetIntervalNumber handles Cb to B (same octave)", () => {
+        // Cb (0) to B (12) should be 1 semitone (wrap-around)
+        GetNotesForInterval.mockReturnValueOnce({
+            firstNote: "Cb",
+            secondNote: "B",
+            octave: 0
+        });
+        expect(Singer.IntervalsActions.GetIntervalNumber(0)).toBe(1);
+    });
+
+    test("GetIntervalNumber handles normal interval correctly", () => {
+        // C (1) to G (8) should be 7 semitones (perfect fifth)
+        GetNotesForInterval.mockReturnValueOnce({
+            firstNote: "C",
+            secondNote: "G",
+            octave: 0
+        });
+        expect(Singer.IntervalsActions.GetIntervalNumber(0)).toBe(7);
+    });
+
     test("GetCurrentInterval normal", () => {
         expect(typeof Singer.IntervalsActions.GetCurrentInterval(0)).toBe("string");
     });