From a4ab8e1b06e80c9092b75fb5bd8107aa24f288a0 Mon Sep 17 00:00:00 2001
From: Aria <weglossing@gmail.com>
Date: Wed, 6 Aug 2025 00:45:01 -0500
Subject: [PATCH 1/8] First pass at extending scale function to include notes

---
 packages/tonal/tonal.mjs     | 113 ++++++++++++++++++++++-------------
 packages/tonal/tonleiter.mjs |  14 ++++-
 2 files changed, 84 insertions(+), 43 deletions(-)

diff --git a/packages/tonal/tonal.mjs b/packages/tonal/tonal.mjs
index c4dd54880..2aca7e9cb 100644
--- a/packages/tonal/tonal.mjs
+++ b/packages/tonal/tonal.mjs
@@ -6,7 +6,8 @@ This program is free software: you can redistribute it and/or modify it under th
 
 import { Note, Interval, Scale } from '@tonaljs/tonal';
 import { register, _mod, silence, logger, pure, isNote } from '@strudel/core';
-import { stepInNamedScale } from './tonleiter.mjs';
+import { stepInNamedScale, scaleToChromas } from './tonleiter.mjs';
+import { noteToMidi } from '../core/util.mjs'
 
 const octavesInterval = (octaves) => (octaves <= 0 ? -1 : 1) + octaves * 7 + 'P';
 
@@ -171,8 +172,52 @@ export const { scaleTranspose, scaleTrans, strans } = register(
   },
 );
 
+// Converts a step value, which is a number optionally decorated with sharps and flats,
+// to a number and an `offset` number of semitones
+function _convertStepToNumberAndOffset(step) {
+  if (isNote(step)) {
+    // legacy..
+    return pure(step);
+  }
+  let asNumber = Number(step);
+  let offset = 0;
+  if (isNaN(asNumber)) {
+    step = String(step);
+    // Check to see if the format correctly matches the expected one of
+    // Optionally starting with + or -
+    // A number
+    // Some number of sharps or flats (but not both)
+    const match = /^[-+]?(\d+)((#{1,})|(b{1,}))?$/.exec(step);
+
+    if (!match) {
+      logger(
+        `[tonal] invalid scale step "${step}", expected number or integer with optional # b suffixes`,
+        'error',
+      );
+      return silence;
+    }
+    asNumber = Number(match[2]);
+    // The number of semitones will be given by either the total number of sharps (match 3)
+    // or the negative of the total number of flats (match 4)
+    offset = match[3].length > 0 ? match[3].length : -match[4].length;
+  }
+  return [asNumber, offset];
+}
+
+// Finds the nearest (named) scale note to `note` (a string which is then converted to a midi number)
+function _getNearestScaleNote(scaleName, note) {
+  let midiNote = noteToMidi(note);
+  const octave = (midiNote / 12) >> 0;
+  const goal = midiNote % 12;
+  const chromas = scaleToChromas(scaleName);
+  return chromas.reduce((prev, curr) => {
+    return Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev;
+  }) + octave * 12;
+}
+
 /**
- * Turns numbers into notes in the scale (zero indexed). Also sets scale for other scale operations, like {@link Pattern#scaleTranspose}.
+ * Turns numbers into notes in the scale (zero indexed) or quantizes notes to a scale.
+ * Also sets scale for other scale operations, like {@link Pattern#scaleTranspose}.
  *
  * A scale consists of a root note (e.g. `c4`, `c`, `f#`, `bb4`) followed by semicolon (':') and then a [scale type](https://github.com/tonaljs/tonal/blob/main/packages/scale-type/data.ts).
  *
@@ -200,58 +245,42 @@ export const scale = register(
     if (Array.isArray(scale)) {
       scale = scale.flat().join(' ');
     }
-    return (
+    let output = (
       pat
         .fmap((value) => {
           const isObject = typeof value === 'object';
-          let step = isObject ? value.n : value;
-          if (isObject) {
+          // The case where the note has been defined via `n`
+          if ((isObject && 'n' in value) || !isObject) {
+            let step = isObject ? value.n : value;
+            debugger;
             delete value.n; // remove n so it won't cause trouble
-          }
-          if (isNote(step)) {
-            // legacy..
-            return pure(step);
-          }
-          let asNumber = Number(step);
-          let semitones = 0;
-          if (isNaN(asNumber)) {
-            step = String(step);
-            if (!/^[-+]?\d+(#*|b*){1}$/.test(step)) {
-              logger(
-                `[tonal] invalid scale step "${step}", expected number or integer with optional # b suffixes`,
-                'error',
-              );
-              return silence;
-            }
-            const isharp = step.indexOf('#');
-            if (isharp >= 0) {
-              asNumber = Number(step.substring(0, isharp));
-              semitones = step.length - isharp;
-            } else {
-              const iflat = step.indexOf('b');
-              asNumber = Number(step.substring(0, iflat));
-              semitones = iflat - step.length;
+            let [number, offset] = _convertStepToNumberAndOffset(step);
+            try {
+              let note;
+              if (isObject && value.anchor) {
+                note = stepInNamedScale(number, scale, value.anchor);
+              } else {
+                note = scaleStep(number, scale);
+              }
+              if (offset != 0) note = Note.transpose(note, Interval.fromSemitones(offset));
+              value = pure(isObject ? { ...value, note } : note);
+            } catch (err) {
+              logger(`[tonal] ${err.message}`, 'error');
+              value = silence;
             }
+            return value;
           }
-          try {
-            let note;
-            if (isObject && value.anchor) {
-              note = stepInNamedScale(asNumber, scale, value.anchor);
-            } else {
-              note = scaleStep(asNumber, scale);
-            }
-            if (semitones != 0) note = Note.transpose(note, Interval.fromSemitones(semitones));
-            value = pure(isObject ? { ...value, note } : note);
-          } catch (err) {
-            logger(`[tonal] ${err.message}`, 'error');
-            value = silence;
+          // The case where the note has been defined via `note`
+          else {
+            let note = _getNearestScaleNote(scale, value.note);
+            return pure(isObject ? { ...value, note } : note);
           }
-          return value;
         })
         .outerJoin()
         // legacy:
         .withHap((hap) => hap.setContext({ ...hap.context, scale }))
     );
+    return output;
   },
   true,
   true, // preserve step count
diff --git a/packages/tonal/tonleiter.mjs b/packages/tonal/tonleiter.mjs
index 3814394f6..63ae9c942 100644
--- a/packages/tonal/tonleiter.mjs
+++ b/packages/tonal/tonleiter.mjs
@@ -222,6 +222,7 @@ export const Note = {
 };
 
 // TODO: support octave numbers
+// Example: Note("Bb3").transpose("c3")
 export function transpose(note, step) {
   // example: E, 3
   const stepNumber = Step.tokenize(step)[1]; // 3
@@ -236,4 +237,15 @@ export function transpose(note, step) {
   return [targetNote, offsetAccidentals].join('');
 }
 
-//Note("Bb3").transpose("c3")
+// Converts a `scaleName` into a corresponding list of chromas between 0 and 12
+export function scaleToChromas (scaleName) {
+  if (Array.isArray(scaleName)) {
+    scaleName = scaleName.flat().join(' ');
+  }
+  const [tonic, name] = Scale.tokenize(scaleName);
+  const rootMidi = noteToMidi(tonic);
+  const chroma = rootMidi % 12;
+  const intervals = Scale.get(name).intervals;
+  const scaleSteps = intervals.map(Interval.semitones);
+  return scaleSteps.map(s => (s + chroma) % 12);
+}

From 7046c1f54669f26a93252349af28e6adca4b6310 Mon Sep 17 00:00:00 2001
From: Aria <weglossing@gmail.com>
Date: Wed, 6 Aug 2025 10:17:48 -0500
Subject: [PATCH 2/8] Cleanup and simplification; improved docstrings

---
 packages/tonal/tonal.mjs | 43 +++++++++++++++++++++++-----------------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/packages/tonal/tonal.mjs b/packages/tonal/tonal.mjs
index 2aca7e9cb..5b0c63b97 100644
--- a/packages/tonal/tonal.mjs
+++ b/packages/tonal/tonal.mjs
@@ -183,11 +183,10 @@ function _convertStepToNumberAndOffset(step) {
   let offset = 0;
   if (isNaN(asNumber)) {
     step = String(step);
-    // Check to see if the format correctly matches the expected one of
-    // Optionally starting with + or -
-    // A number
-    // Some number of sharps or flats (but not both)
-    const match = /^[-+]?(\d+)((#{1,})|(b{1,}))?$/.exec(step);
+    // Check to see if the step matches the expected format:
+    //   - A number (possibly negative)
+    //   - Some number of sharps or flats (but not both)
+    const match = /^(-?\d+)(#+|b+)?$/.exec(step);
 
     if (!match) {
       logger(
@@ -196,27 +195,33 @@ function _convertStepToNumberAndOffset(step) {
       );
       return silence;
     }
-    asNumber = Number(match[2]);
-    // The number of semitones will be given by either the total number of sharps (match 3)
-    // or the negative of the total number of flats (match 4)
-    offset = match[3].length > 0 ? match[3].length : -match[4].length;
+    asNumber = Number(match[1]);
+    // These decorations will determine the semitone offset based on the number of
+    // sharps or flats
+    const decorations = match[2] || '';
+    offset = decorations[0] === '#' ? decorations.length : -decorations.length;
   }
   return [asNumber, offset];
 }
 
-// Finds the nearest (named) scale note to `note` (a string which is then converted to a midi number)
+// Finds the nearest scale note to `note`
 function _getNearestScaleNote(scaleName, note) {
-  let midiNote = noteToMidi(note);
+  let midiNote = typeof note === 'string' ? noteToMidi(note) : note;
   const octave = (midiNote / 12) >> 0;
-  const goal = midiNote % 12;
-  const chromas = scaleToChromas(scaleName);
-  return chromas.reduce((prev, curr) => {
-    return Math.abs(curr - goal) < Math.abs(prev - goal) ? curr : prev;
+  const targetChroma = midiNote % 12;
+  const scaleChromas = scaleToChromas(scaleName);
+  return scaleChromas.reduce((prev, curr) => {
+    // Include equality so ties are broken upwards
+    return Math.abs(curr - targetChroma) <= Math.abs(prev - targetChroma) ? curr : prev;
   }) + octave * 12;
 }
 
 /**
  * Turns numbers into notes in the scale (zero indexed) or quantizes notes to a scale.
+ *
+ * When describing notes via numbers, note that negative numbers can be used to wrap backwards
+ * in the scale as well as sharps or flats (but not both) to produce notes outside of the scale.
+ *
  * Also sets scale for other scale operations, like {@link Pattern#scaleTranspose}.
  *
  * A scale consists of a root note (e.g. `c4`, `c`, `f#`, `bb4`) followed by semicolon (':') and then a [scale type](https://github.com/tonaljs/tonal/blob/main/packages/scale-type/data.ts).
@@ -236,6 +241,10 @@ function _getNearestScaleNote(scaleName, note) {
  * n(rand.range(0,12).segment(8))
  * .scale("C:ritusen")
  * .s("piano")
+ * @example
+ * n("<[0,7b] [-4# -4] [-2,7##] 4 [0,7] [-4# -4b] [-2,7###] 4b>*4")
+ * .scale("C:<major minor>/2")
+ * .s("piano")
  */
 
 export const scale = register(
@@ -245,14 +254,13 @@ export const scale = register(
     if (Array.isArray(scale)) {
       scale = scale.flat().join(' ');
     }
-    let output = (
+    return (
       pat
         .fmap((value) => {
           const isObject = typeof value === 'object';
           // The case where the note has been defined via `n`
           if ((isObject && 'n' in value) || !isObject) {
             let step = isObject ? value.n : value;
-            debugger;
             delete value.n; // remove n so it won't cause trouble
             let [number, offset] = _convertStepToNumberAndOffset(step);
             try {
@@ -280,7 +288,6 @@ export const scale = register(
         // legacy:
         .withHap((hap) => hap.setContext({ ...hap.context, scale }))
     );
-    return output;
   },
   true,
   true, // preserve step count

From a4c040e10134c8978fdeda318bddb93caf5fa267 Mon Sep 17 00:00:00 2001
From: Aria <weglossing@gmail.com>
Date: Wed, 6 Aug 2025 12:37:55 -0500
Subject: [PATCH 3/8] Add new tests, organize old tests, fix issue with  note

---
 packages/tonal/test/tonal.test.mjs | 171 +++++++++++++++++------------
 packages/tonal/tonal.mjs           |  32 +++---
 packages/tonal/tonleiter.mjs       |   4 +-
 3 files changed, 120 insertions(+), 87 deletions(-)

diff --git a/packages/tonal/test/tonal.test.mjs b/packages/tonal/test/tonal.test.mjs
index cd8b3c88b..5486d5135 100644
--- a/packages/tonal/test/tonal.test.mjs
+++ b/packages/tonal/test/tonal.test.mjs
@@ -7,80 +7,113 @@ This program is free software: you can redistribute it and/or modify it under th
 // import { strict as assert } from 'assert';
 
 import '../tonal.mjs'; // need to import this to add prototypes
-import { pure, n, seq, note } from '@strudel/core';
+import { pure, n, seq, note, noteToMidi } from '@strudel/core';
 import { describe, it, expect } from 'vitest';
 import { mini } from '../../mini/mini.mjs';
 
 describe('tonal', () => {
-  it('Should run tonal functions ', () => {
-    expect(pure('c3').scale('C major').scaleTranspose(1).firstCycleValues).toEqual(['D3']);
+  describe('scaleTranspose', () => {
+    it('transposes notes by scale degrees', () => {
+      expect(pure('c3').scale('C major').scaleTranspose(1).firstCycleValues).toEqual(['D3']);
+    });
   });
-  it('scale with plain values', () => {
-    expect(
-      seq(0, 1, 2)
-        .scale('C major')
-        .note()
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
+  describe('scale', () => {
+    it('converts plain values', () => {
+      expect(
+        seq(0, 1, 2)
+          .scale('C major')
+          .note()
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts n values', () => {
+      expect(
+        n(seq(0, 1, 2))
+          .scale('C major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts n values (mini notation)', () => {
+      expect(
+        n(seq(0, 1, 2))
+          .scale('C:major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts n values (no tonic)', () => {
+      expect(
+        n(seq(0, 1, 2))
+          .scale('major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts n values (explicit mini notation)', () => {
+      expect(
+        n(seq(0, 1, 2))
+          .scale(mini('C:major'))
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C3', 'D3', 'E3']);
+    });
+    it('converts decorated n values', () => {
+      expect(
+        n(seq('0b', '1#', '-2', '3##', '4bb'))
+          .scale('C major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['B2', 'Eb3', 'A2', 'G3', 'F3']);
+    });
+    it('produces silence for mixed sharps and flats', () => {
+      expect(
+        n(seq('0b#', '1#b', '2#b#'))
+          .scale('C major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['', '', '']);
+    });
+    it('snaps notes (upwards) to scale', () => {
+      const inputNotes = ['Cb', 'Eb', 'G', 'A#', 'Bb'];
+      let expectedNotes = ['B2', 'E3', 'G3', 'B3', 'B3'];
+
+      // Notes are converted to midi by scale
+      expectedNotes = expectedNotes.map((note) => noteToMidi(note));
+
+      expect(
+        note(seq(inputNotes))
+          .scale('C major')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(expectedNotes);
+    });
   });
-  it('scale with n values', () => {
-    expect(
-      n(seq(0, 1, 2))
-        .scale('C major')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
-  });
-  it('scale with colon', () => {
-    expect(
-      n(seq(0, 1, 2))
-        .scale('C:major')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
-  });
-  it('scale without tonic', () => {
-    expect(
-      n(seq(0, 1, 2))
-        .scale('major')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
-  });
-  it('scale with mininotation colon', () => {
-    expect(
-      n(seq(0, 1, 2))
-        .scale(mini('C:major'))
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C3', 'D3', 'E3']);
-  });
-  it('transposes note numbers with interval numbers', () => {
-    expect(
-      note(seq(40, 40, 40))
-        .transpose(0, 1, 2)
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual([40, 41, 42]);
-    expect(seq(40, 40, 40).transpose(0, 1, 2).firstCycleValues).toEqual([40, 41, 42]);
-  });
-  it('transposes note numbers with interval strings', () => {
-    expect(
-      note(seq(40, 40, 40))
-        .transpose('1P', '2M', '3m')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual([40, 42, 43]);
-    expect(seq(40, 40, 40).transpose('1P', '2M', '3m').firstCycleValues).toEqual([40, 42, 43]);
-  });
-  it('transposes note strings with interval numbers', () => {
-    expect(
-      note(seq('c', 'c', 'c'))
-        .transpose(0, 1, 2)
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C', 'Db', 'D']);
-    expect(seq('c', 'c', 'c').transpose(0, 1, 2).firstCycleValues).toEqual(['C', 'Db', 'D']);
-  });
-  it('transposes note strings with interval strings', () => {
-    expect(
-      note(seq('c', 'c', 'c'))
-        .transpose('1P', '2M', '3m')
-        .firstCycleValues.map((h) => h.note),
-    ).toEqual(['C', 'D', 'Eb']);
-    expect(seq('c', 'c', 'c').transpose('1P', '2M', '3m').firstCycleValues).toEqual(['C', 'D', 'Eb']);
+  describe('transpose', () => {
+    it('transposes note numbers with interval numbers', () => {
+      expect(
+        note(seq(40, 40, 40))
+          .transpose(0, 1, 2)
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual([40, 41, 42]);
+      expect(seq(40, 40, 40).transpose(0, 1, 2).firstCycleValues).toEqual([40, 41, 42]);
+    });
+    it('transposes note numbers with interval strings', () => {
+      expect(
+        note(seq(40, 40, 40))
+          .transpose('1P', '2M', '3m')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual([40, 42, 43]);
+      expect(seq(40, 40, 40).transpose('1P', '2M', '3m').firstCycleValues).toEqual([40, 42, 43]);
+    });
+    it('transposes note strings with interval numbers', () => {
+      expect(
+        note(seq('c', 'c', 'c'))
+          .transpose(0, 1, 2)
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C', 'Db', 'D']);
+      expect(seq('c', 'c', 'c').transpose(0, 1, 2).firstCycleValues).toEqual(['C', 'Db', 'D']);
+    });
+    it('transposes note strings with interval strings', () => {
+      expect(
+        note(seq('c', 'c', 'c'))
+          .transpose('1P', '2M', '3m')
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(['C', 'D', 'Eb']);
+      expect(seq('c', 'c', 'c').transpose('1P', '2M', '3m').firstCycleValues).toEqual(['C', 'D', 'Eb']);
+    });
   });
 });
diff --git a/packages/tonal/tonal.mjs b/packages/tonal/tonal.mjs
index 5b0c63b97..5e505c75a 100644
--- a/packages/tonal/tonal.mjs
+++ b/packages/tonal/tonal.mjs
@@ -7,7 +7,7 @@ This program is free software: you can redistribute it and/or modify it under th
 import { Note, Interval, Scale } from '@tonaljs/tonal';
 import { register, _mod, silence, logger, pure, isNote } from '@strudel/core';
 import { stepInNamedScale, scaleToChromas } from './tonleiter.mjs';
-import { noteToMidi } from '../core/util.mjs'
+import { noteToMidi } from '../core/util.mjs';
 
 const octavesInterval = (octaves) => (octaves <= 0 ? -1 : 1) + octaves * 7 + 'P';
 
@@ -175,25 +175,18 @@ export const { scaleTranspose, scaleTrans, strans } = register(
 // Converts a step value, which is a number optionally decorated with sharps and flats,
 // to a number and an `offset` number of semitones
 function _convertStepToNumberAndOffset(step) {
-  if (isNote(step)) {
-    // legacy..
-    return pure(step);
-  }
   let asNumber = Number(step);
   let offset = 0;
   if (isNaN(asNumber)) {
     step = String(step);
     // Check to see if the step matches the expected format:
-    //   - A number (possibly negative)
-    //   - Some number of sharps or flats (but not both)
+    // - A number (possibly negative)
+    // - Some number of sharps or flats (but not both)
     const match = /^(-?\d+)(#+|b+)?$/.exec(step);
 
     if (!match) {
-      logger(
-        `[tonal] invalid scale step "${step}", expected number or integer with optional # b suffixes`,
-        'error',
-      );
-      return silence;
+      logger(`[tonal] invalid scale step "${step}", expected number or integer with optional # b suffixes`, 'error');
+      return [silence, 0];
     }
     asNumber = Number(match[1]);
     // These decorations will determine the semitone offset based on the number of
@@ -210,10 +203,13 @@ function _getNearestScaleNote(scaleName, note) {
   const octave = (midiNote / 12) >> 0;
   const targetChroma = midiNote % 12;
   const scaleChromas = scaleToChromas(scaleName);
-  return scaleChromas.reduce((prev, curr) => {
-    // Include equality so ties are broken upwards
-    return Math.abs(curr - targetChroma) <= Math.abs(prev - targetChroma) ? curr : prev;
-  }) + octave * 12;
+  return (
+    scaleChromas.reduce((prev, curr) => {
+      // Include equality so ties are broken upwards
+      return Math.abs(curr - targetChroma) <= Math.abs(prev - targetChroma) ? curr : prev;
+    }) +
+    octave * 12
+  );
 }
 
 /**
@@ -262,6 +258,10 @@ export const scale = register(
           if ((isObject && 'n' in value) || !isObject) {
             let step = isObject ? value.n : value;
             delete value.n; // remove n so it won't cause trouble
+            if (isNote(step)) {
+              // legacy..
+              return pure(step);
+            }
             let [number, offset] = _convertStepToNumberAndOffset(step);
             try {
               let note;
diff --git a/packages/tonal/tonleiter.mjs b/packages/tonal/tonleiter.mjs
index 63ae9c942..39c819cd7 100644
--- a/packages/tonal/tonleiter.mjs
+++ b/packages/tonal/tonleiter.mjs
@@ -238,7 +238,7 @@ export function transpose(note, step) {
 }
 
 // Converts a `scaleName` into a corresponding list of chromas between 0 and 12
-export function scaleToChromas (scaleName) {
+export function scaleToChromas(scaleName) {
   if (Array.isArray(scaleName)) {
     scaleName = scaleName.flat().join(' ');
   }
@@ -247,5 +247,5 @@ export function scaleToChromas (scaleName) {
   const chroma = rootMidi % 12;
   const intervals = Scale.get(name).intervals;
   const scaleSteps = intervals.map(Interval.semitones);
-  return scaleSteps.map(s => (s + chroma) % 12);
+  return scaleSteps.map((s) => (s + chroma) % 12);
 }

From c8c6a2ce08e0fca7857323156ba2a8adf877cd5c Mon Sep 17 00:00:00 2001
From: Aria <weglossing@gmail.com>
Date: Fri, 15 Aug 2025 13:34:43 -0500
Subject: [PATCH 4/8] Add example test and update fastChunk test (which was
 previously broken)

---
 test/__snapshots__/examples.test.mjs.snap | 37 +++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/test/__snapshots__/examples.test.mjs.snap b/test/__snapshots__/examples.test.mjs.snap
index eb6c238d5..1b5e73d34 100644
--- a/test/__snapshots__/examples.test.mjs.snap
+++ b/test/__snapshots__/examples.test.mjs.snap
@@ -3418,6 +3418,8 @@ exports[`runs examples > example "fast" example index 0 1`] = `
 
 exports[`runs examples > example "fastChunk" example index 0 1`] = `
 [
+  "[ 0/1 → 1/4 | color:red note:0 ]",
+  "[ 1/4 → 1/2 | color:red note:1 ]",
   "[ 1/2 → 3/4 | note:E2 ]",
   "[ 3/4 → 1/1 | note:F2 ]",
   "[ 1/1 → 5/4 | note:G2 ]",
@@ -3426,6 +3428,8 @@ exports[`runs examples > example "fastChunk" example index 0 1`] = `
   "[ 7/4 → 2/1 | note:C3 ]",
   "[ 2/1 → 9/4 | note:D3 ]",
   "[ 9/4 → 5/2 | note:D2 ]",
+  "[ 5/2 → 11/4 | color:red note:2 ]",
+  "[ 11/4 → 3/1 | color:red note:3 ]",
   "[ 3/1 → 13/4 | note:G2 ]",
   "[ 13/4 → 7/2 | note:A2 ]",
   "[ 7/2 → 15/4 | note:B2 ]",
@@ -8414,6 +8418,39 @@ exports[`runs examples > example "scale" example index 2 1`] = `
 ]
 `;
 
+exports[`runs examples > example "scale" example index 3 1`] = `
+[
+  "[ 0/1 → 1/4 | note:C3 s:piano ]",
+  "[ 0/1 → 1/4 | note:B3 s:piano ]",
+  "[ 1/4 → 3/8 | note:Gb2 s:piano ]",
+  "[ 3/8 → 1/2 | note:F2 s:piano ]",
+  "[ 1/2 → 3/4 | note:A2 s:piano ]",
+  "[ 1/2 → 3/4 | note:D4 s:piano ]",
+  "[ 3/4 → 1/1 | note:G3 s:piano ]",
+  "[ 1/1 → 5/4 | note:C3 s:piano ]",
+  "[ 1/1 → 5/4 | note:C4 s:piano ]",
+  "[ 5/4 → 11/8 | note:Gb2 s:piano ]",
+  "[ 11/8 → 3/2 | note:E2 s:piano ]",
+  "[ 3/2 → 7/4 | note:A2 s:piano ]",
+  "[ 3/2 → 7/4 | note:Eb4 s:piano ]",
+  "[ 7/4 → 2/1 | note:F#3 s:piano ]",
+  "[ 2/1 → 9/4 | note:C3 s:piano ]",
+  "[ 2/1 → 9/4 | note:B3 s:piano ]",
+  "[ 9/4 → 19/8 | note:Gb2 s:piano ]",
+  "[ 19/8 → 5/2 | note:F2 s:piano ]",
+  "[ 5/2 → 11/4 | note:Ab2 s:piano ]",
+  "[ 5/2 → 11/4 | note:D4 s:piano ]",
+  "[ 11/4 → 3/1 | note:G3 s:piano ]",
+  "[ 3/1 → 13/4 | note:C3 s:piano ]",
+  "[ 3/1 → 13/4 | note:C4 s:piano ]",
+  "[ 13/4 → 27/8 | note:Gb2 s:piano ]",
+  "[ 27/8 → 7/2 | note:E2 s:piano ]",
+  "[ 7/2 → 15/4 | note:Ab2 s:piano ]",
+  "[ 7/2 → 15/4 | note:Eb4 s:piano ]",
+  "[ 15/4 → 4/1 | note:F#3 s:piano ]",
+]
+`;
+
 exports[`runs examples > example "scaleTranspose" example index 0 1`] = `
 [
   "[ 0/1 → 1/2 | note:C3 ]",

From b08890bd9e7604ca374b954d655c5c3e5333d991 Mon Sep 17 00:00:00 2001
From: Aria <weglossing@gmail.com>
Date: Fri, 22 Aug 2025 11:25:13 -0500
Subject: [PATCH 5/8] Working version with note names

---
 packages/tonal/test/tonal.test.mjs | 25 ++++++++--
 packages/tonal/tonal.mjs           | 79 ++++++++++++++++++++----------
 packages/tonal/tonleiter.mjs       | 17 +------
 3 files changed, 75 insertions(+), 46 deletions(-)

diff --git a/packages/tonal/test/tonal.test.mjs b/packages/tonal/test/tonal.test.mjs
index 5486d5135..a64b455b9 100644
--- a/packages/tonal/test/tonal.test.mjs
+++ b/packages/tonal/test/tonal.test.mjs
@@ -70,10 +70,7 @@ describe('tonal', () => {
     });
     it('snaps notes (upwards) to scale', () => {
       const inputNotes = ['Cb', 'Eb', 'G', 'A#', 'Bb'];
-      let expectedNotes = ['B2', 'E3', 'G3', 'B3', 'B3'];
-
-      // Notes are converted to midi by scale
-      expectedNotes = expectedNotes.map((note) => noteToMidi(note));
+      const expectedNotes = ['B2', 'E3', 'G3', 'B3', 'B3'];
 
       expect(
         note(seq(inputNotes))
@@ -81,6 +78,26 @@ describe('tonal', () => {
           .firstCycleValues.map((h) => h.note),
       ).toEqual(expectedNotes);
     });
+    it('snaps notes to the correct octave', () => {
+      const inputNotes = ['Cb0', 'Eb4', 'G1', 'A#19', 'Bb8'];
+      const expectedNotes = ['B#0', 'D#4', 'G#1', 'A#19', 'A#8'];
+
+      expect(
+        note(seq(inputNotes))
+          .scale('A# minor') // A#, B#, C#, D#, E#, F#, G#
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(expectedNotes);
+    });
+    it('handles scale names provided with colons', () => {
+      const inputNotes = ['Cb', 'E', 'G', 'A#', 'Bb'];
+      const expectedNotes = ['A#2', 'D#3', 'G#3', 'A#3', 'A#3'];
+
+      expect(
+        note(seq(inputNotes))
+          .scale('F#:pentatonic') // F#, G#, A#, C#, and D#
+          .firstCycleValues.map((h) => h.note),
+      ).toEqual(expectedNotes);
+    });
   });
   describe('transpose', () => {
     it('transposes note numbers with interval numbers', () => {
diff --git a/packages/tonal/tonal.mjs b/packages/tonal/tonal.mjs
index 5e505c75a..28e2606e1 100644
--- a/packages/tonal/tonal.mjs
+++ b/packages/tonal/tonal.mjs
@@ -6,20 +6,28 @@ This program is free software: you can redistribute it and/or modify it under th
 
 import { Note, Interval, Scale } from '@tonaljs/tonal';
 import { register, _mod, silence, logger, pure, isNote } from '@strudel/core';
-import { stepInNamedScale, scaleToChromas } from './tonleiter.mjs';
+import { stepInNamedScale, nearestNumberIndex } from './tonleiter.mjs';
 import { noteToMidi } from '../core/util.mjs';
 
 const octavesInterval = (octaves) => (octaves <= 0 ? -1 : 1) + octaves * 7 + 'P';
 
-function scaleStep(step, scale) {
-  scale = scale.replaceAll(':', ' ');
-  step = Math.ceil(step);
-  let { intervals, tonic, empty } = Scale.get(scale);
-  if ((empty && isNote(scale)) || (empty && !tonic)) {
-    throw new Error(`incomplete scale. Make sure to use ":" instead of spaces, example: .scale("C:major")`);
+function getScale(scaleName) {
+  scaleName = scaleName.replaceAll(':', ' ');
+  const scale = Scale.get(scaleName);
+  const { tonic, empty } = scale;
+  if ((empty && isNote(scaleName)) || (empty && !tonic)) {
+    throw new Error(
+      `Scale name ${scaleName} is incomplete. Make sure to use ":" instead of spaces, example: .scale("C:major")`,
+    );
   } else if (empty) {
-    throw new Error(`invalid scale "${scale}"`);
+    throw new Error(`Invalid scale name "${scaleName}"`);
   }
+  return scale;
+}
+
+function scaleStep(step, scale) {
+  step = Math.ceil(step);
+  let { intervals, tonic } = getScale(scale);
   tonic = tonic || 'C';
   const { pc, oct = 3 } = Note.get(tonic);
   const octaveOffset = Math.floor(step / intervals.length);
@@ -31,8 +39,7 @@ function scaleStep(step, scale) {
 // transpose note inside scale by offset steps
 // function scaleOffset(scale: string, offset: number, note: string) {
 function scaleOffset(scale, offset, note) {
-  let [tonic, scaleName] = Scale.tokenize(scale);
-  let { notes } = Scale.get(`${tonic} ${scaleName}`);
+  let { notes } = getScale(scale);
   notes = notes.map((note) => Note.get(note).pc); // use only pc!
   offset = Number(offset);
   if (isNaN(offset)) {
@@ -197,19 +204,37 @@ function _convertStepToNumberAndOffset(step) {
   return [asNumber, offset];
 }
 
+let scaleToMidisAndNotes = {};
 // Finds the nearest scale note to `note`
-function _getNearestScaleNote(scaleName, note) {
-  let midiNote = typeof note === 'string' ? noteToMidi(note) : note;
-  const octave = (midiNote / 12) >> 0;
-  const targetChroma = midiNote % 12;
-  const scaleChromas = scaleToChromas(scaleName);
-  return (
-    scaleChromas.reduce((prev, curr) => {
-      // Include equality so ties are broken upwards
-      return Math.abs(curr - targetChroma) <= Math.abs(prev - targetChroma) ? curr : prev;
-    }) +
-    octave * 12
-  );
+function _getNearestScaleNote(scaleName, note, preferHigher = true) {
+  let noteMidi = typeof note === 'string' ? noteToMidi(note) : note;
+  noteMidi = Math.max(noteMidi, 24); // we will not play notes below C0
+  if (scaleToMidisAndNotes[scaleName] === undefined) {
+    const { intervals, tonic } = getScale(scaleName);
+    const { pc } = Note.get(tonic);
+    const expandedIntervals = intervals.concat('8P'); // add the octave for wrapping
+    const sNotes = expandedIntervals.map((interval) => Note.transpose(pc + '0', interval));
+    const sMidi = sNotes.map(noteToMidi);
+    // Cache
+    scaleToMidisAndNotes[scaleName] = [sMidi, sNotes];
+  }
+  const [scaleMidis, scaleNotes] = scaleToMidisAndNotes[scaleName];
+  const rootMidi = scaleMidis[0];
+  const octaveDiff = Math.floor((noteMidi - rootMidi) / 12);
+  let filteredNotes = []; // we must filter the notes to avoid negative octave values
+  let filteredMidis = [];
+  for (let i = 0; i < scaleMidis.length; i++) {
+    const newMidi = scaleMidis[i] + 12 * octaveDiff;
+    if (newMidi < 24) {
+      continue;
+    }
+    filteredMidis.push(newMidi);
+    const oldNote = scaleNotes[i];
+    const newNote = Note.transpose(oldNote, Interval.fromSemitones(12 * octaveDiff));
+    filteredNotes.push(newNote);
+  }
+  const noteIdx = nearestNumberIndex(noteMidi, filteredMidis, preferHigher);
+  return filteredNotes[noteIdx];
 }
 
 /**
@@ -254,15 +279,15 @@ export const scale = register(
       pat
         .fmap((value) => {
           const isObject = typeof value === 'object';
-          // The case where the note has been defined via `n`
-          if ((isObject && 'n' in value) || !isObject) {
-            let step = isObject ? value.n : value;
+          // The case where the note has been defined via `n` or `pure`
+          if (!isObject || (isObject && ('n' in value || 'value' in value))) {
+            const step = isObject ? (value.n ?? value.value) : value;
             delete value.n; // remove n so it won't cause trouble
             if (isNote(step)) {
               // legacy..
               return pure(step);
             }
-            let [number, offset] = _convertStepToNumberAndOffset(step);
+            const [number, offset] = _convertStepToNumberAndOffset(step);
             try {
               let note;
               if (isObject && value.anchor) {
@@ -280,7 +305,7 @@ export const scale = register(
           }
           // The case where the note has been defined via `note`
           else {
-            let note = _getNearestScaleNote(scale, value.note);
+            const note = _getNearestScaleNote(scale, value.note);
             return pure(isObject ? { ...value, note } : note);
           }
         })
diff --git a/packages/tonal/tonleiter.mjs b/packages/tonal/tonleiter.mjs
index 39c819cd7..233129641 100644
--- a/packages/tonal/tonleiter.mjs
+++ b/packages/tonal/tonleiter.mjs
@@ -101,11 +101,11 @@ export function nearestNumberIndex(target, numbers, preferHigher) {
 let scaleSteps = {}; // [scaleName]: semitones[]
 
 export function stepInNamedScale(step, scale, anchor, preferHigher) {
-  let [root, scaleName] = Scale.tokenize(scale);
+  const [root, scaleName] = Scale.tokenize(scale);
   const rootMidi = x2midi(root);
   const rootChroma = midi2chroma(rootMidi);
   if (!scaleSteps[scaleName]) {
-    let { intervals } = Scale.get(`C ${scaleName}`);
+    const { intervals } = Scale.get(`C ${scaleName}`);
     // cache result
     scaleSteps[scaleName] = intervals.map(step2semitones);
   }
@@ -236,16 +236,3 @@ export function transpose(note, step) {
   const offsetAccidentals = accidentalString(Step.accidentals(step) + Note.accidentals(note) + stepIndex - indexOffset); // "we need to add a # to to the G to make it a major third from E"
   return [targetNote, offsetAccidentals].join('');
 }
-
-// Converts a `scaleName` into a corresponding list of chromas between 0 and 12
-export function scaleToChromas(scaleName) {
-  if (Array.isArray(scaleName)) {
-    scaleName = scaleName.flat().join(' ');
-  }
-  const [tonic, name] = Scale.tokenize(scaleName);
-  const rootMidi = noteToMidi(tonic);
-  const chroma = rootMidi % 12;
-  const intervals = Scale.get(name).intervals;
-  const scaleSteps = intervals.map(Interval.semitones);
-  return scaleSteps.map((s) => (s + chroma) % 12);
-}

From 79453ac2c3c71a1ba4d2ce34471cd125a2744cd5 Mon Sep 17 00:00:00 2001
From: Aria <weglossing@gmail.com>
Date: Fri, 22 Aug 2025 13:17:13 -0500
Subject: [PATCH 6/8] Allow negatives and multi-accidentals

---
 packages/core/util.mjs             |  4 ++--
 packages/superdough/util.mjs       |  2 +-
 packages/tonal/test/tonal.test.mjs |  2 +-
 packages/tonal/tonal.mjs           | 24 +++++-------------------
 4 files changed, 9 insertions(+), 23 deletions(-)

diff --git a/packages/core/util.mjs b/packages/core/util.mjs
index 2e7c6e026..ef3f1e961 100644
--- a/packages/core/util.mjs
+++ b/packages/core/util.mjs
@@ -8,12 +8,12 @@ import { logger } from './logger.mjs';
 
 // returns true if the given string is a note
 export const isNoteWithOctave = (name) => /^[a-gA-G][#bs]*[0-9]$/.test(name);
-export const isNote = (name) => /^[a-gA-G][#bsf]*[0-9]?$/.test(name);
+export const isNote = (name) => /^[a-gA-G][#bsf]*-?[0-9]?$/.test(name);
 export const tokenizeNote = (note) => {
   if (typeof note !== 'string') {
     return [];
   }
-  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bsf]*)([0-9]*)$/)?.slice(1) || [];
+  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bsf]*)(-?[0-9]*)$/)?.slice(1) || [];
   if (!pc) {
     return [];
   }
diff --git a/packages/superdough/util.mjs b/packages/superdough/util.mjs
index f4d59024e..764ebb43e 100644
--- a/packages/superdough/util.mjs
+++ b/packages/superdough/util.mjs
@@ -7,7 +7,7 @@ export const tokenizeNote = (note) => {
   if (typeof note !== 'string') {
     return [];
   }
-  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bsf]*)([0-9]*)$/)?.slice(1) || [];
+  const [pc, acc = '', oct] = note.match(/^([a-gA-G])([#bsf]*)(-?[0-9]*)$/)?.slice(1) || [];
   if (!pc) {
     return [];
   }
diff --git a/packages/tonal/test/tonal.test.mjs b/packages/tonal/test/tonal.test.mjs
index a64b455b9..cb856fa99 100644
--- a/packages/tonal/test/tonal.test.mjs
+++ b/packages/tonal/test/tonal.test.mjs
@@ -80,7 +80,7 @@ describe('tonal', () => {
     });
     it('snaps notes to the correct octave', () => {
       const inputNotes = ['Cb0', 'Eb4', 'G1', 'A#19', 'Bb8'];
-      const expectedNotes = ['B#0', 'D#4', 'G#1', 'A#19', 'A#8'];
+      const expectedNotes = ['B#-1', 'D#4', 'G#1', 'A#19', 'A#8'];
 
       expect(
         note(seq(inputNotes))
diff --git a/packages/tonal/tonal.mjs b/packages/tonal/tonal.mjs
index 28e2606e1..2ec698c38 100644
--- a/packages/tonal/tonal.mjs
+++ b/packages/tonal/tonal.mjs
@@ -128,10 +128,7 @@ export const { transpose, trans } = register(['transpose', 'trans'], function tr
     const interval = !isNaN(Number(intervalOrSemitones))
       ? Interval.fromSemitones(intervalOrSemitones)
       : String(intervalOrSemitones);
-    // TODO: move simplify to player to preserve enharmonics
-    // tone.js doesn't understand multiple sharps flats e.g. F##3 has to be turned into G3
-    // TODO: check if this is still relevant..
-    const targetNote = Note.simplify(Note.transpose(note, interval));
+    const targetNote = Note.transpose(note, interval);
     if (typeof hap.value === 'object') {
       return hap.withValue(() => ({ ...hap.value, note: targetNote }));
     }
@@ -208,7 +205,6 @@ let scaleToMidisAndNotes = {};
 // Finds the nearest scale note to `note`
 function _getNearestScaleNote(scaleName, note, preferHigher = true) {
   let noteMidi = typeof note === 'string' ? noteToMidi(note) : note;
-  noteMidi = Math.max(noteMidi, 24); // we will not play notes below C0
   if (scaleToMidisAndNotes[scaleName] === undefined) {
     const { intervals, tonic } = getScale(scaleName);
     const { pc } = Note.get(tonic);
@@ -221,20 +217,10 @@ function _getNearestScaleNote(scaleName, note, preferHigher = true) {
   const [scaleMidis, scaleNotes] = scaleToMidisAndNotes[scaleName];
   const rootMidi = scaleMidis[0];
   const octaveDiff = Math.floor((noteMidi - rootMidi) / 12);
-  let filteredNotes = []; // we must filter the notes to avoid negative octave values
-  let filteredMidis = [];
-  for (let i = 0; i < scaleMidis.length; i++) {
-    const newMidi = scaleMidis[i] + 12 * octaveDiff;
-    if (newMidi < 24) {
-      continue;
-    }
-    filteredMidis.push(newMidi);
-    const oldNote = scaleNotes[i];
-    const newNote = Note.transpose(oldNote, Interval.fromSemitones(12 * octaveDiff));
-    filteredNotes.push(newNote);
-  }
-  const noteIdx = nearestNumberIndex(noteMidi, filteredMidis, preferHigher);
-  return filteredNotes[noteIdx];
+  const alignedMidis = scaleMidis.map((m) => m + 12 * octaveDiff);
+  const noteIdx = nearestNumberIndex(noteMidi, alignedMidis, preferHigher);
+  const noteMatch = scaleNotes[noteIdx];
+  return Note.transpose(noteMatch, Interval.fromSemitones(12 * octaveDiff));
 }
 
 /**

From b8c46d6b26f7b3d5864c3f3b02e1ec90468a510d Mon Sep 17 00:00:00 2001
From: Aria <weglossing@gmail.com>
Date: Fri, 22 Aug 2025 13:23:41 -0500
Subject: [PATCH 7/8] Added some description and examples of multi-accidentals
 and negative octaves

---
 packages/core/controls.mjs                |  4 +-
 packages/tonal/tonal.mjs                  |  2 +
 test/__snapshots__/examples.test.mjs.snap | 90 +++++++++++++++++++++++
 3 files changed, 95 insertions(+), 1 deletion(-)

diff --git a/packages/core/controls.mjs b/packages/core/controls.mjs
index e6181d453..de152d417 100644
--- a/packages/core/controls.mjs
+++ b/packages/core/controls.mjs
@@ -113,7 +113,7 @@ export const { n } = registerControl('n');
  *
  * - a letter (a-g or A-G)
  * - optional accidentals (b or #)
- * - optional octave number (0-9). Defaults to 3
+ * - optional (possibly negative) octave number (0-9). Defaults to 3
  *
  * Examples of valid note names: `c`, `bb`, `Bb`, `f#`, `c3`, `A4`, `Eb2`, `c#5`
  *
@@ -126,6 +126,8 @@ export const { n } = registerControl('n');
  * note("c4 a4 f4 e4")
  * @example
  * note("60 69 65 64")
+ * @example
+ * note("fbb1 a#0 cbbb-1 e##-2").sound("saw")
  */
 export const { note } = registerControl(['note', 'n']);
 
diff --git a/packages/tonal/tonal.mjs b/packages/tonal/tonal.mjs
index 2ec698c38..4f189e3d6 100644
--- a/packages/tonal/tonal.mjs
+++ b/packages/tonal/tonal.mjs
@@ -252,6 +252,8 @@ function _getNearestScaleNote(scaleName, note, preferHigher = true) {
  * n("<[0,7b] [-4# -4] [-2,7##] 4 [0,7] [-4# -4b] [-2,7###] 4b>*4")
  * .scale("C:<major minor>/2")
  * .s("piano")
+ * @example
+ * note("C1*16").transpose(irand(36)).scale('Cb2 major').scaleTranspose(3)
  */
 
 export const scale = register(
diff --git a/test/__snapshots__/examples.test.mjs.snap b/test/__snapshots__/examples.test.mjs.snap
index 09482375e..77c2773ce 100644
--- a/test/__snapshots__/examples.test.mjs.snap
+++ b/test/__snapshots__/examples.test.mjs.snap
@@ -6436,6 +6436,27 @@ exports[`runs examples > example "note" example index 2 1`] = `
 ]
 `;
 
+exports[`runs examples > example "note" example index 3 1`] = `
+[
+  "[ 0/1 → 1/4 | note:fbb1 s:saw ]",
+  "[ 1/4 → 1/2 | note:a#0 s:saw ]",
+  "[ 1/2 → 3/4 | note:cbbb-1 s:saw ]",
+  "[ 3/4 → 1/1 | note:e##-2 s:saw ]",
+  "[ 1/1 → 5/4 | note:fbb1 s:saw ]",
+  "[ 5/4 → 3/2 | note:a#0 s:saw ]",
+  "[ 3/2 → 7/4 | note:cbbb-1 s:saw ]",
+  "[ 7/4 → 2/1 | note:e##-2 s:saw ]",
+  "[ 2/1 → 9/4 | note:fbb1 s:saw ]",
+  "[ 9/4 → 5/2 | note:a#0 s:saw ]",
+  "[ 5/2 → 11/4 | note:cbbb-1 s:saw ]",
+  "[ 11/4 → 3/1 | note:e##-2 s:saw ]",
+  "[ 3/1 → 13/4 | note:fbb1 s:saw ]",
+  "[ 13/4 → 7/2 | note:a#0 s:saw ]",
+  "[ 7/2 → 15/4 | note:cbbb-1 s:saw ]",
+  "[ 15/4 → 4/1 | note:e##-2 s:saw ]",
+]
+`;
+
 exports[`runs examples > example "nrpnn" example index 0 1`] = `
 [
   "[ 0/1 → 1/1 | note:c4 nrpnn:[1 8] nrpv:123 midichan:1 ]",
@@ -8699,6 +8720,75 @@ exports[`runs examples > example "scale" example index 3 1`] = `
 ]
 `;
 
+exports[`runs examples > example "scale" example index 4 1`] = `
+[
+  "[ 0/1 → 1/16 | note:Gb1 ]",
+  "[ 1/16 → 1/8 | note:Gb1 ]",
+  "[ 1/8 → 3/16 | note:Gb1 ]",
+  "[ 3/16 → 1/4 | note:Gb1 ]",
+  "[ 1/4 → 5/16 | note:Gb1 ]",
+  "[ 5/16 → 3/8 | note:Gb1 ]",
+  "[ 3/8 → 7/16 | note:Gb1 ]",
+  "[ 7/16 → 1/2 | note:Gb1 ]",
+  "[ 1/2 → 9/16 | note:Gb1 ]",
+  "[ 9/16 → 5/8 | note:Gb1 ]",
+  "[ 5/8 → 11/16 | note:Gb1 ]",
+  "[ 11/16 → 3/4 | note:Gb1 ]",
+  "[ 3/4 → 13/16 | note:Gb1 ]",
+  "[ 13/16 → 7/8 | note:Gb1 ]",
+  "[ 7/8 → 15/16 | note:Gb1 ]",
+  "[ 15/16 → 1/1 | note:Gb1 ]",
+  "[ 1/1 → 17/16 | note:Cb3 ]",
+  "[ 17/16 → 9/8 | note:Cb3 ]",
+  "[ 9/8 → 19/16 | note:Cb3 ]",
+  "[ 19/16 → 5/4 | note:Cb3 ]",
+  "[ 5/4 → 21/16 | note:Cb3 ]",
+  "[ 21/16 → 11/8 | note:Cb3 ]",
+  "[ 11/8 → 23/16 | note:Cb3 ]",
+  "[ 23/16 → 3/2 | note:Cb3 ]",
+  "[ 3/2 → 25/16 | note:Cb3 ]",
+  "[ 25/16 → 13/8 | note:Cb3 ]",
+  "[ 13/8 → 27/16 | note:Cb3 ]",
+  "[ 27/16 → 7/4 | note:Cb3 ]",
+  "[ 7/4 → 29/16 | note:Cb3 ]",
+  "[ 29/16 → 15/8 | note:Cb3 ]",
+  "[ 15/8 → 31/16 | note:Cb3 ]",
+  "[ 31/16 → 2/1 | note:Cb3 ]",
+  "[ 2/1 → 33/16 | note:Eb4 ]",
+  "[ 33/16 → 17/8 | note:Eb4 ]",
+  "[ 17/8 → 35/16 | note:Eb4 ]",
+  "[ 35/16 → 9/4 | note:Eb4 ]",
+  "[ 9/4 → 37/16 | note:Eb4 ]",
+  "[ 37/16 → 19/8 | note:Eb4 ]",
+  "[ 19/8 → 39/16 | note:Eb4 ]",
+  "[ 39/16 → 5/2 | note:Eb4 ]",
+  "[ 5/2 → 41/16 | note:Eb4 ]",
+  "[ 41/16 → 21/8 | note:Eb4 ]",
+  "[ 21/8 → 43/16 | note:Eb4 ]",
+  "[ 43/16 → 11/4 | note:Eb4 ]",
+  "[ 11/4 → 45/16 | note:Eb4 ]",
+  "[ 45/16 → 23/8 | note:Eb4 ]",
+  "[ 23/8 → 47/16 | note:Eb4 ]",
+  "[ 47/16 → 3/1 | note:Eb4 ]",
+  "[ 3/1 → 49/16 | note:Db2 ]",
+  "[ 49/16 → 25/8 | note:Db2 ]",
+  "[ 25/8 → 51/16 | note:Db2 ]",
+  "[ 51/16 → 13/4 | note:Db2 ]",
+  "[ 13/4 → 53/16 | note:Db2 ]",
+  "[ 53/16 → 27/8 | note:Db2 ]",
+  "[ 27/8 → 55/16 | note:Db2 ]",
+  "[ 55/16 → 7/2 | note:Db2 ]",
+  "[ 7/2 → 57/16 | note:Db2 ]",
+  "[ 57/16 → 29/8 | note:Db2 ]",
+  "[ 29/8 → 59/16 | note:Db2 ]",
+  "[ 59/16 → 15/4 | note:Db2 ]",
+  "[ 15/4 → 61/16 | note:Db2 ]",
+  "[ 61/16 → 31/8 | note:Db2 ]",
+  "[ 31/8 → 63/16 | note:Db2 ]",
+  "[ 63/16 → 4/1 | note:Db2 ]",
+]
+`;
+
 exports[`runs examples > example "scaleTranspose" example index 0 1`] = `
 [
   "[ 0/1 → 1/2 | note:C3 ]",

From 92b2013cf6efa9f29372060ab6a052081633cb23 Mon Sep 17 00:00:00 2001
From: Aria <weglossing@gmail.com>
Date: Sun, 14 Sep 2025 17:04:39 -0500
Subject: [PATCH 8/8] Correctly handle silences for non-notes

---
 packages/tonal/test/tonal.test.mjs | 2 +-
 packages/tonal/tonal.mjs           | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/packages/tonal/test/tonal.test.mjs b/packages/tonal/test/tonal.test.mjs
index cb856fa99..5f61b05a9 100644
--- a/packages/tonal/test/tonal.test.mjs
+++ b/packages/tonal/test/tonal.test.mjs
@@ -66,7 +66,7 @@ describe('tonal', () => {
         n(seq('0b#', '1#b', '2#b#'))
           .scale('C major')
           .firstCycleValues.map((h) => h.note),
-      ).toEqual(['', '', '']);
+      ).toEqual([]);
     });
     it('snaps notes (upwards) to scale', () => {
       const inputNotes = ['Cb', 'Eb', 'G', 'A#', 'Bb'];
diff --git a/packages/tonal/tonal.mjs b/packages/tonal/tonal.mjs
index 4f189e3d6..ae75ab690 100644
--- a/packages/tonal/tonal.mjs
+++ b/packages/tonal/tonal.mjs
@@ -189,8 +189,7 @@ function _convertStepToNumberAndOffset(step) {
     const match = /^(-?\d+)(#+|b+)?$/.exec(step);
 
     if (!match) {
-      logger(`[tonal] invalid scale step "${step}", expected number or integer with optional # b suffixes`, 'error');
-      return [silence, 0];
+      throw new Error(`invalid scale step "${step}", expected number or integer with optional # b suffixes`);
     }
     asNumber = Number(match[1]);
     // These decorations will determine the semitone offset based on the number of
@@ -275,8 +274,8 @@ export const scale = register(
               // legacy..
               return pure(step);
             }
-            const [number, offset] = _convertStepToNumberAndOffset(step);
             try {
+              const [number, offset] = _convertStepToNumberAndOffset(step);
               let note;
               if (isObject && value.anchor) {
                 note = stepInNamedScale(number, scale, value.anchor);
@@ -287,7 +286,7 @@ export const scale = register(
               value = pure(isObject ? { ...value, note } : note);
             } catch (err) {
               logger(`[tonal] ${err.message}`, 'error');
-              value = silence;
+              return silence;
             }
             return value;
           }