@sudobility/music_types 0.11.20 → 0.11.21

package/dist/domain/instruments/gm-transposition.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Semitones to add to `program`'s sounding pitch to get its written pitch.
+ *
+ * `0` for anything written where it sounds, and for any program outside
+ * 0-127: an unknown instrument is left alone rather than moved by a guess,
+ * which would be a silently wrong part.
+ */
+export declare function gmWrittenTransposition(program: number): number;
+/** Whether `program` is written anywhere other than where it sounds. */
+export declare function gmIsTransposing(program: number): boolean;
+//# sourceMappingURL=gm-transposition.d.ts.map

package/dist/domain/instruments/gm-transposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gm-transposition.d.ts","sourceRoot":"","sources":["../../../src/domain/instruments/gm-transposition.ts"],"names":[],"mappings":"AA0DA;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAG9D;AAED,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD"}

package/dist/domain/instruments/gm-transposition.js

@@ -0,0 +1,69 @@
+/**
+ * How far a General MIDI program's written pitch sits from its sounding pitch.
+ *
+ * A transposing instrument is written in a key other than the one it sounds: a
+ * B♭ trumpet reads a tone above what comes out, so concert C is written D.
+ * This is a property of the instrument, not a preference — hand a clarinettist
+ * a part at concert pitch and every note is wrong.
+ *
+ * Curated like `gm-range.ts` and `gm-polyphony.ts`: a default with overrides
+ * for the programs that actually transpose. Most do not, so the table below is
+ * only the exceptions.
+ */
+import { gmInstrument } from './gm.js';
+/** Semitones to ADD to sounding pitch to get written pitch. */
+const PROGRAM_TRANSPOSITION = {
+    // Octave-transposing tuned percussion: written an octave (or two) below
+    // where they sound, so the reader is not chasing ledger lines.
+    8: -12, // Celesta
+    9: -24, // Glockenspiel
+    13: -12, // Xylophone
+    // Guitars and basses are written an octave above where they sound.
+    24: 12, // Acoustic Guitar (nylon)
+    25: 12, // Acoustic Guitar (steel)
+    26: 12, // Electric Guitar (jazz)
+    27: 12, // Electric Guitar (clean)
+    28: 12, // Electric Guitar (muted)
+    29: 12, // Overdriven Guitar
+    30: 12, // Distortion Guitar
+    31: 12, // Guitar Harmonics
+    32: 12, // Acoustic Bass
+    33: 12, // Electric Bass (finger)
+    34: 12, // Electric Bass (pick)
+    35: 12, // Fretless Bass
+    36: 12, // Slap Bass 1
+    37: 12, // Slap Bass 2
+    38: 12, // Synth Bass 1
+    39: 12, // Synth Bass 2
+    43: 12, // Contrabass
+    // Brass.
+    56: 2, // Trumpet — B♭
+    60: 7, // French Horn — F
+    // Reeds. The saxophone family transposes by four different intervals, which
+    // is why they cannot share a family default.
+    64: 2, // Soprano Sax — B♭
+    65: 9, // Alto Sax — E♭
+    66: 14, // Tenor Sax — B♭, a ninth below
+    67: 21, // Baritone Sax — E♭, an octave and a sixth below
+    69: 7, // English Horn — F
+    71: 2, // Clarinet — B♭
+    // Pipes.
+    72: -12, // Piccolo — sounds an octave above where it is written
+};
+/**
+ * Semitones to add to `program`'s sounding pitch to get its written pitch.
+ *
+ * `0` for anything written where it sounds, and for any program outside
+ * 0-127: an unknown instrument is left alone rather than moved by a guess,
+ * which would be a silently wrong part.
+ */
+export function gmWrittenTransposition(program) {
+    if (!gmInstrument(program))
+        return 0;
+    return PROGRAM_TRANSPOSITION[program] ?? 0;
+}
+/** Whether `program` is written anywhere other than where it sounds. */
+export function gmIsTransposing(program) {
+    return gmWrittenTransposition(program) !== 0;
+}
+//# sourceMappingURL=gm-transposition.js.map

package/dist/domain/instruments/gm-transposition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gm-transposition.js","sourceRoot":"","sources":["../../../src/domain/instruments/gm-transposition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,+DAA+D;AAC/D,MAAM,qBAAqB,GAA2B;IACpD,wEAAwE;IACxE,+DAA+D;IAC/D,CAAC,EAAE,CAAC,EAAE,EAAE,UAAU;IAClB,CAAC,EAAE,CAAC,EAAE,EAAE,eAAe;IACvB,EAAE,EAAE,CAAC,EAAE,EAAE,YAAY;IAErB,mEAAmE;IACnE,EAAE,EAAE,EAAE,EAAE,0BAA0B;IAClC,EAAE,EAAE,EAAE,EAAE,0BAA0B;IAClC,EAAE,EAAE,EAAE,EAAE,yBAAyB;IACjC,EAAE,EAAE,EAAE,EAAE,0BAA0B;IAClC,EAAE,EAAE,EAAE,EAAE,0BAA0B;IAClC,EAAE,EAAE,EAAE,EAAE,oBAAoB;IAC5B,EAAE,EAAE,EAAE,EAAE,oBAAoB;IAC5B,EAAE,EAAE,EAAE,EAAE,mBAAmB;IAC3B,EAAE,EAAE,EAAE,EAAE,gBAAgB;IACxB,EAAE,EAAE,EAAE,EAAE,yBAAyB;IACjC,EAAE,EAAE,EAAE,EAAE,uBAAuB;IAC/B,EAAE,EAAE,EAAE,EAAE,gBAAgB;IACxB,EAAE,EAAE,EAAE,EAAE,cAAc;IACtB,EAAE,EAAE,EAAE,EAAE,cAAc;IACtB,EAAE,EAAE,EAAE,EAAE,eAAe;IACvB,EAAE,EAAE,EAAE,EAAE,eAAe;IACvB,EAAE,EAAE,EAAE,EAAE,aAAa;IAErB,SAAS;IACT,EAAE,EAAE,CAAC,EAAE,eAAe;IACtB,EAAE,EAAE,CAAC,EAAE,kBAAkB;IAEzB,4EAA4E;IAC5E,6CAA6C;IAC7C,EAAE,EAAE,CAAC,EAAE,mBAAmB;IAC1B,EAAE,EAAE,CAAC,EAAE,gBAAgB;IACvB,EAAE,EAAE,EAAE,EAAE,gCAAgC;IACxC,EAAE,EAAE,EAAE,EAAE,iDAAiD;IACzD,EAAE,EAAE,CAAC,EAAE,mBAAmB;IAC1B,EAAE,EAAE,CAAC,EAAE,gBAAgB;IAEvB,SAAS;IACT,EAAE,EAAE,CAAC,EAAE,EAAE,uDAAuD;CACjE,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,OAAe;IACpD,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;QAAE,OAAO,CAAC,CAAC;IACrC,OAAO,qBAAqB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC7C,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,OAAO,sBAAsB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAC/C,CAAC"}

package/dist/domain/instruments/gm.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The General MIDI Level 1 sound set: 128 programs, grouped into 16 families
+ * of 8. Pure data and lookups — no Tone, no VexFlow, no store.
+ *
+ * `Track.midiProgram` is exactly a program number from this table, and
+ * `music_types` already validates it to 0-127, so this module never has to
+ * defend against a bad value from the schema — only against a hand-edited
+ * score, which is why `gmInstrument` returns `null` rather than throwing.
+ */
+export type GmFamily = 'piano' | 'chromatic-percussion' | 'organ' | 'guitar' | 'bass' | 'strings' | 'ensemble' | 'brass' | 'reed' | 'pipe' | 'synth-lead' | 'synth-pad' | 'synth-effects' | 'ethnic' | 'percussive' | 'sound-effects';
+export type GmInstrument = {
+    /** 0-127, matching `Track.midiProgram`. */
+    program: number;
+    /** The General MIDI name, e.g. "Acoustic Grand Piano". */
+    name: string;
+    family: GmFamily;
+};
+/** In program order: family `i` covers programs `i*8 .. i*8+7`. */
+export declare const GM_FAMILIES: readonly GmFamily[];
+export declare const GM_FAMILY_LABELS: Record<GmFamily, string>;
+/** The family a program belongs to. Arithmetic, because families are runs of eight. */
+export declare function gmFamilyOf(program: number): GmFamily;
+export declare const GM_INSTRUMENTS: readonly GmInstrument[];
+/** `null` for anything that is not an integer in 0-127. */
+export declare function gmInstrument(program: number): GmInstrument | null;
+/** The eight programs of one family, in program order — what the picker groups by. */
+export declare function gmInstrumentsByFamily(family: GmFamily): readonly GmInstrument[];
+//# sourceMappingURL=gm.d.ts.map

package/dist/domain/instruments/gm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gm.d.ts","sourceRoot":"","sources":["../../../src/domain/instruments/gm.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,QAAQ,GAChB,OAAO,GACP,sBAAsB,GACtB,OAAO,GACP,QAAQ,GACR,MAAM,GACN,SAAS,GACT,UAAU,GACV,OAAO,GACP,MAAM,GACN,MAAM,GACN,YAAY,GACZ,WAAW,GACX,eAAe,GACf,QAAQ,GACR,YAAY,GACZ,eAAe,CAAC;AAEpB,MAAM,MAAM,YAAY,GAAG;IACzB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,QAAQ,CAAC;CAClB,CAAC;AAEF,mEAAmE;AACnE,eAAO,MAAM,WAAW,EAAE,SAAS,QAAQ,EAiB1C,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAiBrD,CAAC;AA0JF,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAEpD;AAED,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EAMjD,CAAC;AAEF,2DAA2D;AAC3D,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAGjE;AAED,sFAAsF;AACtF,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,QAAQ,GACf,SAAS,YAAY,EAAE,CAEzB"}

package/dist/domain/instruments/gm.js

@@ -0,0 +1,217 @@
+/**
+ * The General MIDI Level 1 sound set: 128 programs, grouped into 16 families
+ * of 8. Pure data and lookups — no Tone, no VexFlow, no store.
+ *
+ * `Track.midiProgram` is exactly a program number from this table, and
+ * `music_types` already validates it to 0-127, so this module never has to
+ * defend against a bad value from the schema — only against a hand-edited
+ * score, which is why `gmInstrument` returns `null` rather than throwing.
+ */
+/** In program order: family `i` covers programs `i*8 .. i*8+7`. */
+export const GM_FAMILIES = [
+    'piano',
+    'chromatic-percussion',
+    'organ',
+    'guitar',
+    'bass',
+    'strings',
+    'ensemble',
+    'brass',
+    'reed',
+    'pipe',
+    'synth-lead',
+    'synth-pad',
+    'synth-effects',
+    'ethnic',
+    'percussive',
+    'sound-effects',
+];
+export const GM_FAMILY_LABELS = {
+    piano: 'Piano',
+    'chromatic-percussion': 'Chromatic Percussion',
+    organ: 'Organ',
+    guitar: 'Guitar',
+    bass: 'Bass',
+    strings: 'Strings',
+    ensemble: 'Ensemble',
+    brass: 'Brass',
+    reed: 'Reed',
+    pipe: 'Pipe',
+    'synth-lead': 'Synth Lead',
+    'synth-pad': 'Synth Pad',
+    'synth-effects': 'Synth Effects',
+    ethnic: 'Ethnic',
+    percussive: 'Percussive',
+    'sound-effects': 'Sound Effects',
+};
+/**
+ * The 128 names in program order. Families are NOT stored per row: they are a
+ * contiguous run of eight, so `gmFamilyOf` derives them and the table cannot
+ * drift out of sync with `GM_FAMILIES`.
+ */
+const GM_NAMES = [
+    // 0-7 Piano
+    'Acoustic Grand Piano',
+    'Bright Acoustic Piano',
+    'Electric Grand Piano',
+    'Honky-tonk Piano',
+    'Electric Piano 1',
+    'Electric Piano 2',
+    'Harpsichord',
+    'Clavinet',
+    // 8-15 Chromatic Percussion
+    'Celesta',
+    'Glockenspiel',
+    'Music Box',
+    'Vibraphone',
+    'Marimba',
+    'Xylophone',
+    'Tubular Bells',
+    'Dulcimer',
+    // 16-23 Organ
+    'Drawbar Organ',
+    'Percussive Organ',
+    'Rock Organ',
+    'Church Organ',
+    'Reed Organ',
+    'Accordion',
+    'Harmonica',
+    'Tango Accordion',
+    // 24-31 Guitar
+    'Acoustic Guitar (nylon)',
+    'Acoustic Guitar (steel)',
+    'Electric Guitar (jazz)',
+    'Electric Guitar (clean)',
+    'Electric Guitar (muted)',
+    'Overdriven Guitar',
+    'Distortion Guitar',
+    'Guitar Harmonics',
+    // 32-39 Bass
+    'Acoustic Bass',
+    'Electric Bass (finger)',
+    'Electric Bass (pick)',
+    'Fretless Bass',
+    'Slap Bass 1',
+    'Slap Bass 2',
+    'Synth Bass 1',
+    'Synth Bass 2',
+    // 40-47 Strings
+    'Violin',
+    'Viola',
+    'Cello',
+    'Contrabass',
+    'Tremolo Strings',
+    'Pizzicato Strings',
+    'Orchestral Harp',
+    'Timpani',
+    // 48-55 Ensemble
+    'String Ensemble 1',
+    'String Ensemble 2',
+    'Synth Strings 1',
+    'Synth Strings 2',
+    'Choir Aahs',
+    'Voice Oohs',
+    'Synth Voice',
+    'Orchestra Hit',
+    // 56-63 Brass
+    'Trumpet',
+    'Trombone',
+    'Tuba',
+    'Muted Trumpet',
+    'French Horn',
+    'Brass Section',
+    'Synth Brass 1',
+    'Synth Brass 2',
+    // 64-71 Reed
+    'Soprano Sax',
+    'Alto Sax',
+    'Tenor Sax',
+    'Baritone Sax',
+    'Oboe',
+    'English Horn',
+    'Bassoon',
+    'Clarinet',
+    // 72-79 Pipe
+    'Piccolo',
+    'Flute',
+    'Recorder',
+    'Pan Flute',
+    'Blown Bottle',
+    'Shakuhachi',
+    'Whistle',
+    'Ocarina',
+    // 80-87 Synth Lead
+    'Lead 1 (square)',
+    'Lead 2 (sawtooth)',
+    'Lead 3 (calliope)',
+    'Lead 4 (chiff)',
+    'Lead 5 (charang)',
+    'Lead 6 (voice)',
+    'Lead 7 (fifths)',
+    'Lead 8 (bass + lead)',
+    // 88-95 Synth Pad
+    'Pad 1 (new age)',
+    'Pad 2 (warm)',
+    'Pad 3 (polysynth)',
+    'Pad 4 (choir)',
+    'Pad 5 (bowed)',
+    'Pad 6 (metallic)',
+    'Pad 7 (halo)',
+    'Pad 8 (sweep)',
+    // 96-103 Synth Effects
+    'FX 1 (rain)',
+    'FX 2 (soundtrack)',
+    'FX 3 (crystal)',
+    'FX 4 (atmosphere)',
+    'FX 5 (brightness)',
+    'FX 6 (goblins)',
+    'FX 7 (echoes)',
+    'FX 8 (sci-fi)',
+    // 104-111 Ethnic
+    'Sitar',
+    'Banjo',
+    'Shamisen',
+    'Koto',
+    'Kalimba',
+    'Bagpipe',
+    'Fiddle',
+    'Shanai',
+    // 112-119 Percussive
+    'Tinkle Bell',
+    'Agogo',
+    'Steel Drums',
+    'Woodblock',
+    'Taiko Drum',
+    'Melodic Tom',
+    'Synth Drum',
+    'Reverse Cymbal',
+    // 120-127 Sound Effects
+    'Guitar Fret Noise',
+    'Breath Noise',
+    'Seashore',
+    'Bird Tweet',
+    'Telephone Ring',
+    'Helicopter',
+    'Applause',
+    'Gunshot',
+];
+/** The family a program belongs to. Arithmetic, because families are runs of eight. */
+export function gmFamilyOf(program) {
+    return GM_FAMILIES[Math.floor(program / 8)];
+}
+export const GM_INSTRUMENTS = GM_NAMES.map((name, program) => ({
+    program,
+    name,
+    family: gmFamilyOf(program),
+}));
+/** `null` for anything that is not an integer in 0-127. */
+export function gmInstrument(program) {
+    if (!Number.isInteger(program) || program < 0 || program > 127)
+        return null;
+    return GM_INSTRUMENTS[program];
+}
+/** The eight programs of one family, in program order — what the picker groups by. */
+export function gmInstrumentsByFamily(family) {
+    return GM_INSTRUMENTS.filter(instrument => instrument.family === family);
+}
+//# sourceMappingURL=gm.js.map

package/dist/domain/instruments/gm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gm.js","sourceRoot":"","sources":["../../../src/domain/instruments/gm.ts"],"names":[],"mappings":"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"}

package/dist/domain/pitch/pitch.d.ts

@@ -0,0 +1,15 @@
+import type { KeySignature, Pitch } from '../../index.js';
+/** Converts a `Pitch` to its MIDI note number (C4 = 60, A4 = 69). */
+export declare function pitchToMidi(p: Pitch): number;
+/**
+ * Converts a MIDI note number to a `Pitch`, choosing an enharmonic spelling
+ * appropriate to the given key signature: sharps for sharp/neutral keys
+ * (`fifths >= 0`), flats for flat keys (`fifths < 0`). Defaults to sharp
+ * spelling when no key signature is given.
+ */
+export declare function midiToPitch(midi: number, keySignature?: KeySignature): Pitch;
+/** Formats a `Pitch` as a string, e.g. `C4`, `F#3`, `Bb4`, `F##4`. */
+export declare function pitchToString(p: Pitch): string;
+/** Whether a pitch's MIDI value falls within an inclusive range. */
+export declare function isPitchInRange(p: Pitch, lowestMidi: number, highestMidi: number): boolean;
+//# sourceMappingURL=pitch.d.ts.map

package/dist/domain/pitch/pitch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pitch.d.ts","sourceRoot":"","sources":["../../../src/domain/pitch/pitch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,YAAY,EACZ,KAAK,EAEN,MAAM,gBAAgB,CAAC;AAiBxB,qEAAqE;AACrE,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAO5C;AAkCD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,YAAY,GAAG,KAAK,CAS5E;AAUD,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAE9C;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAC5B,CAAC,EAAE,KAAK,EACR,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB,OAAO,CAGT"}

package/dist/domain/pitch/pitch.js

@@ -0,0 +1,81 @@
+/** Semitone offset from C for each natural pitch step (no accidental). */
+const NATURAL_STEP_SEMITONES = {
+    C: 0,
+    D: 2,
+    E: 4,
+    F: 5,
+    G: 7,
+    A: 9,
+    B: 11,
+};
+/** MIDI note number for C4 ("middle C"), per spec §4 (C4 = 60). */
+const MIDI_C4 = 60;
+const C4_OCTAVE = 4;
+/** Converts a `Pitch` to its MIDI note number (C4 = 60, A4 = 69). */
+export function pitchToMidi(p) {
+    return (MIDI_C4 +
+        (p.octave - C4_OCTAVE) * 12 +
+        NATURAL_STEP_SEMITONES[p.step] +
+        p.accidental);
+}
+/** step/accidental spelling for each pitch class 0-11, preferring sharps. */
+const SHARP_SPELLING = [
+    { step: 'C', accidental: 0 },
+    { step: 'C', accidental: 1 },
+    { step: 'D', accidental: 0 },
+    { step: 'D', accidental: 1 },
+    { step: 'E', accidental: 0 },
+    { step: 'F', accidental: 0 },
+    { step: 'F', accidental: 1 },
+    { step: 'G', accidental: 0 },
+    { step: 'G', accidental: 1 },
+    { step: 'A', accidental: 0 },
+    { step: 'A', accidental: 1 },
+    { step: 'B', accidental: 0 },
+];
+/** step/accidental spelling for each pitch class 0-11, preferring flats. */
+const FLAT_SPELLING = [
+    { step: 'C', accidental: 0 },
+    { step: 'D', accidental: -1 },
+    { step: 'D', accidental: 0 },
+    { step: 'E', accidental: -1 },
+    { step: 'E', accidental: 0 },
+    { step: 'F', accidental: 0 },
+    { step: 'G', accidental: -1 },
+    { step: 'G', accidental: 0 },
+    { step: 'A', accidental: -1 },
+    { step: 'A', accidental: 0 },
+    { step: 'B', accidental: -1 },
+    { step: 'B', accidental: 0 },
+];
+/**
+ * Converts a MIDI note number to a `Pitch`, choosing an enharmonic spelling
+ * appropriate to the given key signature: sharps for sharp/neutral keys
+ * (`fifths >= 0`), flats for flat keys (`fifths < 0`). Defaults to sharp
+ * spelling when no key signature is given.
+ */
+export function midiToPitch(midi, keySignature) {
+    const useSharps = keySignature === undefined || keySignature.fifths >= 0;
+    const spelling = useSharps ? SHARP_SPELLING : FLAT_SPELLING;
+    const pitchClass = ((midi % 12) + 12) % 12;
+    const octave = Math.floor(midi / 12) - 1;
+    const { step, accidental } = spelling[pitchClass];
+    return { step, accidental, octave };
+}
+const ACCIDENTAL_SYMBOLS = {
+    [-2]: 'bb',
+    [-1]: 'b',
+    [0]: '',
+    [1]: '#',
+    [2]: '##',
+};
+/** Formats a `Pitch` as a string, e.g. `C4`, `F#3`, `Bb4`, `F##4`. */
+export function pitchToString(p) {
+    return `${p.step}${ACCIDENTAL_SYMBOLS[p.accidental]}${p.octave}`;
+}
+/** Whether a pitch's MIDI value falls within an inclusive range. */
+export function isPitchInRange(p, lowestMidi, highestMidi) {
+    const midi = pitchToMidi(p);
+    return midi >= lowestMidi && midi <= highestMidi;
+}
+//# sourceMappingURL=pitch.js.map

package/dist/domain/pitch/pitch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pitch.js","sourceRoot":"","sources":["../../../src/domain/pitch/pitch.ts"],"names":[],"mappings":"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"}

package/dist/domain/pitch/transpose.d.ts

@@ -0,0 +1,37 @@
+import type { KeySignature, Pitch } from '../../index.js';
+/**
+ * Transposes a pitch by a number of semitones (may be negative), re-spelling
+ * the result according to the given key signature (see `midiToPitch`).
+ */
+export declare function transposePitch(p: Pitch, semitones: number, key?: KeySignature): Pitch;
+/**
+ * Shifts a pitch by whole octaves, preserving its step and accidental
+ * (diatonic spelling never changes for an octave-only transposition).
+ */
+export declare function transposeDiatonicOctave(p: Pitch, octaves: number): Pitch;
+/**
+ * Moves `p` by `steps` positions on the staff — one step per line-to-adjacent-
+ * space — keeping its accidental.
+ *
+ * Diatonic, not chromatic, because this exists for dragging a note up and down
+ * a staff: the reader is moving it to a *staff position*, and one position is
+ * a tone in some places and a semitone in others. Transposing by semitones
+ * would make the note refuse to follow the pointer across E-F and B-C.
+ *
+ * The accidental rides along unchanged, which is what a drag should do: moving
+ * F# up one step gives G#, not G. Respelling is the caller's business.
+ */
+export declare function shiftDiatonic(p: Pitch, steps: number): Pitch;
+/**
+ * The key `key` becomes when the music is transposed by `semitones`.
+ *
+ * Moving up a fifth adds one sharp, so a shift of `s` semitones moves the key
+ * by `s × 7` fifths — the circle of fifths advances 7 semitones per step. The
+ * result is folded into -6..6 so a minor third up reads as three flats rather
+ * than nine sharps: both name the same key, but only one is printable.
+ *
+ * An octave leaves the key untouched, which falls out of the arithmetic rather
+ * than needing a special case.
+ */
+export declare function transposeKeySignature(key: KeySignature, semitones: number): KeySignature;
+//# sourceMappingURL=transpose.d.ts.map

package/dist/domain/pitch/transpose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpose.d.ts","sourceRoot":"","sources":["../../../src/domain/pitch/transpose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,KAAK,EAAa,MAAM,gBAAgB,CAAC;AAGrE;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,KAAK,EACR,SAAS,EAAE,MAAM,EACjB,GAAG,CAAC,EAAE,YAAY,GACjB,KAAK,CAEP;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,CAExE;AAKD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAW5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,MAAM,GAChB,YAAY,CAWd"}

package/dist/domain/pitch/transpose.js

@@ -0,0 +1,65 @@
+import { midiToPitch, pitchToMidi } from './pitch.js';
+/**
+ * Transposes a pitch by a number of semitones (may be negative), re-spelling
+ * the result according to the given key signature (see `midiToPitch`).
+ */
+export function transposePitch(p, semitones, key) {
+    return midiToPitch(pitchToMidi(p) + semitones, key);
+}
+/**
+ * Shifts a pitch by whole octaves, preserving its step and accidental
+ * (diatonic spelling never changes for an octave-only transposition).
+ */
+export function transposeDiatonicOctave(p, octaves) {
+    return { ...p, octave: p.octave + octaves };
+}
+/** The seven letter names, in order, for diatonic movement. */
+const STEPS = ['C', 'D', 'E', 'F', 'G', 'A', 'B'];
+/**
+ * Moves `p` by `steps` positions on the staff — one step per line-to-adjacent-
+ * space — keeping its accidental.
+ *
+ * Diatonic, not chromatic, because this exists for dragging a note up and down
+ * a staff: the reader is moving it to a *staff position*, and one position is
+ * a tone in some places and a semitone in others. Transposing by semitones
+ * would make the note refuse to follow the pointer across E-F and B-C.
+ *
+ * The accidental rides along unchanged, which is what a drag should do: moving
+ * F# up one step gives G#, not G. Respelling is the caller's business.
+ */
+export function shiftDiatonic(p, steps) {
+    if (steps === 0)
+        return p;
+    const index = STEPS.indexOf(p.step);
+    if (index < 0)
+        return p;
+    const absolute = index + steps;
+    // Floor division, so it works for downward moves as well as upward.
+    const octaveShift = Math.floor(absolute / STEPS.length);
+    const wrapped = ((absolute % STEPS.length) + STEPS.length) % STEPS.length;
+    return { ...p, step: STEPS[wrapped], octave: p.octave + octaveShift };
+}
+/**
+ * The key `key` becomes when the music is transposed by `semitones`.
+ *
+ * Moving up a fifth adds one sharp, so a shift of `s` semitones moves the key
+ * by `s × 7` fifths — the circle of fifths advances 7 semitones per step. The
+ * result is folded into -6..6 so a minor third up reads as three flats rather
+ * than nine sharps: both name the same key, but only one is printable.
+ *
+ * An octave leaves the key untouched, which falls out of the arithmetic rather
+ * than needing a special case.
+ */
+export function transposeKeySignature(key, semitones) {
+    const raw = (((semitones * 7) % 12) + 12) % 12;
+    const delta = raw > 6 ? raw - 12 : raw;
+    let fifths = key.fifths + delta;
+    // The sum can still land outside the printable range when the starting key
+    // is already remote; fold it back the same way.
+    while (fifths > 7)
+        fifths -= 12;
+    while (fifths < -7)
+        fifths += 12;
+    return { fifths, mode: key.mode };
+}
+//# sourceMappingURL=transpose.js.map

package/dist/domain/pitch/transpose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transpose.js","sourceRoot":"","sources":["../../../src/domain/pitch/transpose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEtD;;;GAGG;AACH,MAAM,UAAU,cAAc,CAC5B,CAAQ,EACR,SAAiB,EACjB,GAAkB;IAElB,OAAO,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,CAAC,CAAC;AACtD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CAAC,CAAQ,EAAE,OAAe;IAC/D,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,GAAG,OAAO,EAAE,CAAC;AAC9C,CAAC;AAED,+DAA+D;AAC/D,MAAM,KAAK,GAAyB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAExE;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAAC,CAAQ,EAAE,KAAa;IACnD,IAAI,KAAK,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAC1B,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,CAAC,CAAC;IAExB,MAAM,QAAQ,GAAG,KAAK,GAAG,KAAK,CAAC;IAC/B,oEAAoE;IACpE,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IACxD,MAAM,OAAO,GAAG,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;IAE1E,OAAO,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,GAAG,WAAW,EAAE,CAAC;AACxE,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB,CACnC,GAAiB,EACjB,SAAiB;IAEjB,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;IAC/C,MAAM,KAAK,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;IAEvC,IAAI,MAAM,GAAG,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC;IAChC,2EAA2E;IAC3E,gDAAgD;IAChD,OAAO,MAAM,GAAG,CAAC;QAAE,MAAM,IAAI,EAAE,CAAC;IAChC,OAAO,MAAM,GAAG,CAAC,CAAC;QAAE,MAAM,IAAI,EAAE,CAAC;IAEjC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC;AACpC,CAAC"}

package/dist/domain/quantization/options.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Options for `quantizeEvents` (spec §24). All fields except `grid`,
+ * `quantizeStarts`, and `quantizeDurations` are opt-in: omitting one of the
+ * optional fields disables that behavior entirely (no implicit defaults are
+ * substituted for them by `quantize.ts`, except a hard, undocumented-by-the-
+ * caller floor of 1 tick so a returned event's `durationTicks` is never
+ * <= 0 regardless of `minDurationTicks`).
+ */
+export type QuantizeOptions = {
+    /** Grid unit in ticks (e.g. 120 ticks = a sixteenth note at 480 ppq). */
+    grid: number;
+    /** Snap each event's `startTick` to the grid (see `tripletGrid`/`swing`/`humanizeToleranceTicks`). */
+    quantizeStarts: boolean;
+    /** Snap each event's `durationTicks` to a multiple of the grid. */
+    quantizeDurations: boolean;
+    /**
+     * Fraction (0..1) of one grid unit that every second grid slot (odd
+     * slot index: 1, 3, 5, ...) is delayed by. 0 = straight (no shift);
+     * 0.5 = classic swung-eighths feel; 1 = fully delayed into the next
+     * slot. Only affects start quantization, and only takes effect when
+     * `quantizeStarts` is true.
+     */
+    swing?: number;
+    /** Use a triplet subdivision of `grid` (2/3 of `grid`) instead of `grid` itself when snapping starts/durations. */
+    tripletGrid?: boolean;
+    /**
+     * Minimum allowed `durationTicks`. A `NoteEvent` whose *original*
+     * duration is shorter than this is dropped entirely (`RestEvent`s are
+     * never dropped). A duration that becomes shorter than this purely as a
+     * quantization rounding artifact is clamped up to this floor instead of
+     * being dropped.
+     */
+    minDurationTicks?: number;
+    /**
+     * If an event's original `startTick` is already within this many ticks
+     * of where start-quantization would snap it, its original `startTick`
+     * is kept instead of being forced onto the grid (a deterministic
+     * "already close enough" tolerance; `quantize.ts` is a pure function, so
+     * this is not randomized humanization).
+     */
+    humanizeToleranceTicks?: number;
+    /**
+     * Events (within the same track+voice) whose quantized start ticks fall
+     * within this many ticks of one another are clustered onto a single
+     * shared start tick (grouped as a chord).
+     */
+    chordToleranceTicks?: number;
+    /** Extend each event's end to meet the next event's start in the same track+voice, closing small gaps. */
+    legatoCleanup?: boolean;
+    /** Trim an event that overlaps the next event's start in the same track+voice, resolving the overlap. */
+    resolveOverlaps?: boolean;
+    /** Insert `RestEvent`s to fill any remaining silent gaps within each track+voice. */
+    fillGaps?: boolean;
+};
+//# sourceMappingURL=options.d.ts.map

package/dist/domain/quantization/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/domain/quantization/options.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAC;IACb,sGAAsG;IACtG,cAAc,EAAE,OAAO,CAAC;IACxB,mEAAmE;IACnE,iBAAiB,EAAE,OAAO,CAAC;IAC3B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mHAAmH;IACnH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,0GAA0G;IAC1G,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,yGAAyG;IACzG,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qFAAqF;IACrF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC"}

package/dist/domain/quantization/options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=options.js.map

package/dist/domain/quantization/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../src/domain/quantization/options.ts"],"names":[],"mappings":""}

package/dist/domain/quantization/quantize.d.ts

@@ -0,0 +1,13 @@
+import type { MusicalEvent } from '../../index.js';
+import type { QuantizeOptions } from './options.js';
+/**
+ * Quantizes `events` per `opts` (spec §24): drops undersized notes, snaps
+ * starts (grid/triplet/swing/humanize tolerance) and durations (grid,
+ * clamped to a minimum), then — per (trackId, voiceId) group — clusters
+ * near-simultaneous onsets into chords, resolves overlaps, closes gaps
+ * (legato), and fills remaining silence with rests. Every stage after
+ * dropping is opt-in via `opts`; omitting a field disables that stage.
+ * Returns a new array; never mutates `events` or its elements.
+ */
+export declare function quantizeEvents(events: MusicalEvent[], opts: QuantizeOptions): MusicalEvent[];
+//# sourceMappingURL=quantize.d.ts.map

package/dist/domain/quantization/quantize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quantize.d.ts","sourceRoot":"","sources":["../../../src/domain/quantization/quantize.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AA2MpD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,YAAY,EAAE,EACtB,IAAI,EAAE,eAAe,GACpB,YAAY,EAAE,CAqBhB"}