tonus 0.1.0

package/dist/engines/temper/data/constants.js

@@ -0,0 +1,150 @@
+// ---------------------------------------------------------------------------
+// engines/temper/data/constants — pitch-class vocabulary, solfège, intervals
+// ---------------------------------------------------------------------------
+/** 12 pitch-class names, index = pitch class 0–11. Sharp-biased except Eb/Ab/Bb. */
+export const PITCH_CLASS = [
+    "C",
+    "C#",
+    "D",
+    "Eb",
+    "E",
+    "F",
+    "F#",
+    "G",
+    "Ab",
+    "A",
+    "Bb",
+    "B",
+];
+/** Diatonic step letters in ascending order. */
+export const DIATONIC_STEPS = ["C", "D", "E", "F", "G", "A", "B"];
+/** Map any note name (including enharmonics) to its pitch class 0–11. */
+export const NAME_TO_CHROMA = new Map([
+    ["C", 0],
+    ["B#", 0],
+    ["C#", 1],
+    ["Db", 1],
+    ["D", 2],
+    ["D#", 3],
+    ["Eb", 3],
+    ["E", 4],
+    ["Fb", 4],
+    ["E#", 5],
+    ["F", 5],
+    ["F#", 6],
+    ["Gb", 6],
+    ["G", 7],
+    ["G#", 8],
+    ["Ab", 8],
+    ["A", 9],
+    ["A#", 10],
+    ["Bb", 10],
+    ["B", 11],
+    ["Cb", 11],
+]);
+// Modern fixed-do solfège → pitch class (input only; UT = C always)
+export const SOLFEGE_TO_CHROMA = new Map([
+    ["UT", 0],
+    ["DO", 0],
+    ["RE", 2],
+    ["MI", 4],
+    ["FA", 5],
+    ["SOL", 7],
+    ["SO", 7],
+    ["LA", 9],
+    ["TE", 10],
+    ["TI", 11],
+    ["SI", 11],
+]);
+// Diatonic pitch class → Guidonian solfège name (UT system, medieval 6-syllable)
+// pc 10 (Bb) = FA in molle hexachord; pc 11 (B) = MI in durum hexachord
+// Chromatic pcs have no canonical name — use lookupGuido() for context-aware solmization
+export const CHROMA_TO_SOLFEGE = new Map([
+    [0, "UT"],
+    [2, "RE"],
+    [4, "MI"],
+    [5, "FA"],
+    [7, "SOL"],
+    [9, "LA"],
+    [10, "FA"], // Bb — b-molle
+    [11, "MI"], // B  — b-durum
+]);
+// Entries indexed by semitone count 0–11.
+// semitone=0: use UNISONUS when abs=0, this entry when abs=12 (octave).
+export const INTERVAL = [
+    {
+        latin: "Octava",
+        alias: "Diapason",
+        degree: 8,
+        quality: "perfect",
+        class: "P8",
+    },
+    { latin: "Semitonium", degree: 2, quality: "minor", class: "m2" },
+    { latin: "Tonus", degree: 2, quality: "major", class: "M2" },
+    { latin: "Tertia minor", degree: 3, quality: "minor", class: "m3" },
+    { latin: "Tertia maior", degree: 3, quality: "major", class: "M3" },
+    {
+        latin: "Quarta",
+        alias: "Diatessaron",
+        degree: 4,
+        quality: "perfect",
+        class: "P4",
+    },
+    { latin: "Tritonus", degree: 4, quality: "augmented", class: "TT" },
+    {
+        latin: "Quinta",
+        alias: "Diapente",
+        degree: 5,
+        quality: "perfect",
+        class: "P5",
+    },
+    { latin: "Sexta minor", degree: 6, quality: "minor", class: "m6" },
+    { latin: "Sexta maior", degree: 6, quality: "major", class: "M6" },
+    { latin: "Septima minor", degree: 7, quality: "minor", class: "m7" },
+    { latin: "Septima maior", degree: 7, quality: "major", class: "M7" },
+];
+export const UNISONUS = {
+    latin: "Unisonus",
+    degree: 1,
+    quality: "perfect",
+    class: "P1",
+};
+// prettier-ignore
+export const SHARP_SPELLING = [
+    { step: "C", acc: 0 }, // 0
+    { step: "C", acc: 1 }, // 1
+    { step: "D", acc: 0 }, // 2
+    { step: "D", acc: 1 }, // 3
+    { step: "E", acc: 0 }, // 4
+    { step: "F", acc: 0 }, // 5
+    { step: "F", acc: 1 }, // 6
+    { step: "G", acc: 0 }, // 7
+    { step: "G", acc: 1 }, // 8
+    { step: "A", acc: 0 }, // 9
+    { step: "A", acc: 1 }, // 10
+    { step: "B", acc: 0 }, // 11
+];
+// prettier-ignore
+export const FLAT_SPELLING = [
+    { step: "C", acc: 0 }, // 0
+    { step: "D", acc: -1 }, // 1
+    { step: "D", acc: 0 }, // 2
+    { step: "E", acc: -1 }, // 3
+    { step: "E", acc: 0 }, // 4
+    { step: "F", acc: 0 }, // 5
+    { step: "G", acc: -1 }, // 6
+    { step: "G", acc: 0 }, // 7
+    { step: "A", acc: -1 }, // 8
+    { step: "A", acc: 0 }, // 9
+    { step: "B", acc: -1 }, // 10
+    { step: "B", acc: 0 }, // 11
+];
+// Prefer flat spelling for Bb, Eb, Ab
+export const PREFER_FLAT_PCS = new Set([3, 8, 10]);
+// Guidonian solmization syllable → pitch class, by hexachord
+export const GUIDO_TO_PC = {
+    durum: { UT: 7, RE: 9, MI: 11, FA: 0, SOL: 2, LA: 4 },
+    naturale: { UT: 0, RE: 2, MI: 4, FA: 5, SOL: 7, LA: 9 },
+    molle: { UT: 5, RE: 7, MI: 9, FA: 10, SOL: 0, LA: 2 },
+};
+//# sourceMappingURL=constants.js.map

package/dist/engines/temper/data/guido.d.ts

@@ -0,0 +1,14 @@
+export interface GuidonianVariant {
+    hexachord: "durum" | "naturale" | "molle";
+    solmization: "UT" | "RE" | "MI" | "FA" | "SOL" | "LA";
+}
+export interface GuidonianEntry {
+    hand: {
+        finger: string;
+        region: string;
+    };
+    name: [string, string];
+    variants: GuidonianVariant[];
+}
+export declare const GUIDONIAN_DATA: Map<number, GuidonianEntry>;
+//# sourceMappingURL=guido.d.ts.map

package/dist/engines/temper/data/guido.js

@@ -0,0 +1,29 @@
+// ---------------------------------------------------------------------------
+// engines/temper/data/guido — Guidonian gamut and hexachord variants
+// ---------------------------------------------------------------------------
+// prettier-ignore
+export const GUIDONIAN_DATA = new Map([
+    [43, { hand: { finger: "base", region: "palm" }, name: ["Γ", "Gammaut"], variants: [{ hexachord: "durum", solmization: "UT" }] }],
+    [45, { hand: { finger: "wrist", region: "center" }, name: ["A", "Are"], variants: [{ hexachord: "durum", solmization: "RE" }] }],
+    [47, { hand: { finger: "wrist", region: "inner" }, name: ["B", "Bemi"], variants: [{ hexachord: "durum", solmization: "MI" }] }],
+    [48, { hand: { finger: "palm", region: "base" }, name: ["C", "Cefaut"], variants: [{ hexachord: "durum", solmization: "FA" }, { hexachord: "naturale", solmization: "UT" }] }],
+    [50, { hand: { finger: "palm", region: "middle" }, name: ["D", "Desolre"], variants: [{ hexachord: "durum", solmization: "SOL" }, { hexachord: "naturale", solmization: "RE" }] }],
+    [52, { hand: { finger: "palm", region: "top" }, name: ["E", "Elami"], variants: [{ hexachord: "durum", solmization: "LA" }, { hexachord: "naturale", solmization: "MI" }] }],
+    [53, { hand: { finger: "thumb", region: "base" }, name: ["F", "Fefaut"], variants: [{ hexachord: "naturale", solmization: "FA" }, { hexachord: "molle", solmization: "UT" }] }],
+    [55, { hand: { finger: "thumb", region: "mid" }, name: ["G", "Gesolreut"], variants: [{ hexachord: "durum", solmization: "UT" }, { hexachord: "naturale", solmization: "SOL" }, { hexachord: "molle", solmization: "RE" }] }],
+    [57, { hand: { finger: "thumb", region: "tip" }, name: ["a", "Alamire"], variants: [{ hexachord: "durum", solmization: "RE" }, { hexachord: "naturale", solmization: "LA" }, { hexachord: "molle", solmization: "MI" }] }],
+    [58, { hand: { finger: "index", region: "base" }, name: ["b", "Befa"], variants: [{ hexachord: "molle", solmization: "FA" }] }],
+    [59, { hand: { finger: "index", region: "mid" }, name: ["♮", "Bemi"], variants: [{ hexachord: "durum", solmization: "MI" }] }],
+    [60, { hand: { finger: "index", region: "tip" }, name: ["c", "Cesolfaut"], variants: [{ hexachord: "durum", solmization: "FA" }, { hexachord: "naturale", solmization: "UT" }, { hexachord: "molle", solmization: "SOL" }] }],
+    [62, { hand: { finger: "middle", region: "base" }, name: ["d", "Delasolre"], variants: [{ hexachord: "durum", solmization: "SOL" }, { hexachord: "naturale", solmization: "RE" }, { hexachord: "molle", solmization: "LA" }] }],
+    [64, { hand: { finger: "middle", region: "mid" }, name: ["e", "Elami"], variants: [{ hexachord: "durum", solmization: "LA" }, { hexachord: "naturale", solmization: "MI" }] }],
+    [65, { hand: { finger: "middle", region: "tip" }, name: ["f", "Fefaut"], variants: [{ hexachord: "naturale", solmization: "FA" }, { hexachord: "molle", solmization: "UT" }] }],
+    [67, { hand: { finger: "ring", region: "base" }, name: ["g", "Gesolreut"], variants: [{ hexachord: "durum", solmization: "UT" }, { hexachord: "naturale", solmization: "SOL" }, { hexachord: "molle", solmization: "RE" }] }],
+    [69, { hand: { finger: "ring", region: "mid" }, name: ["aa", "Alamire"], variants: [{ hexachord: "durum", solmization: "RE" }, { hexachord: "naturale", solmization: "LA" }, { hexachord: "molle", solmization: "MI" }] }],
+    [70, { hand: { finger: "ring", region: "tip" }, name: ["bb", "Befa"], variants: [{ hexachord: "molle", solmization: "FA" }] }],
+    [71, { hand: { finger: "pinky", region: "base" }, name: ["♮♮", "Bemi"], variants: [{ hexachord: "durum", solmization: "MI" }] }],
+    [72, { hand: { finger: "pinky", region: "mid" }, name: ["cc", "Cesolfa"], variants: [{ hexachord: "durum", solmization: "FA" }, { hexachord: "naturale", solmization: "UT" }, { hexachord: "molle", solmization: "SOL" }] }],
+    [74, { hand: { finger: "pinky", region: "top" }, name: ["dd", "Delasol"], variants: [{ hexachord: "durum", solmization: "SOL" }, { hexachord: "naturale", solmization: "RE" }, { hexachord: "molle", solmization: "LA" }] }],
+    [76, { hand: { finger: "pinky", region: "tip" }, name: ["ee", "Ela"], variants: [{ hexachord: "durum", solmization: "LA" }, { hexachord: "naturale", solmization: "MI" }] }],
+]);
+//# sourceMappingURL=guido.js.map

package/dist/engines/temper/data/modes.d.ts

@@ -0,0 +1,38 @@
+export interface ModeProfile {
+    mood: string;
+    phrasing: "recitative" | "lyrical" | "hymnic" | "solemn";
+    melodic: "rising" | "falling" | "arch" | "neutral";
+    tendency: "melismatic" | "neumatic" | "syllabic" | "neutral";
+}
+export interface ModeData {
+    mode: number;
+    nomen: string;
+    alias: string;
+    maneria: string;
+    type: "authentic" | "plagal";
+    final: number;
+    tenor: number;
+    scalePcs: number[];
+    hexachords: ("durum" | "naturale" | "molle")[];
+    profile: ModeProfile;
+    cadences: {
+        final: number[];
+        tenor: number[];
+    };
+    modulations: {
+        regular: number[];
+        conceded: number[];
+        initials: number[];
+    };
+    ambitus: {
+        lowest: number;
+        highest: number;
+        span: number;
+    };
+    species: {
+        fifth: [number, number];
+        fourth: [number, number];
+    };
+}
+export declare const MODES: Map<number, ModeData>;
+//# sourceMappingURL=modes.d.ts.map

package/dist/engines/temper/data/modes.js

@@ -0,0 +1,158 @@
+// ---------------------------------------------------------------------------
+// engines/temper/data/modes — eight Gregorian modes (I–VIII)
+// ---------------------------------------------------------------------------
+export const MODES = new Map([
+    [
+        1,
+        {
+            mode: 1,
+            nomen: "Protus Authenticus",
+            alias: "dorian",
+            maneria: "Protus",
+            type: "authentic",
+            final: 2,
+            tenor: 9,
+            scalePcs: [2, 4, 5, 7, 9, 11, 0],
+            hexachords: ["naturale"],
+            profile: { mood: "serious", phrasing: "lyrical", melodic: "falling", tendency: "melismatic" },
+            cadences: { final: [5, 4, 2], tenor: [9, 2] },
+            modulations: { regular: [2, 9, 5, 7], conceded: [12, 4], initials: [2, 5, 7, 9, 14] },
+            ambitus: { lowest: 2, highest: 21, span: 19 },
+            species: { fifth: [2, 9], fourth: [9, 2] },
+        },
+    ],
+    [
+        2,
+        {
+            mode: 2,
+            nomen: "Protus Plagalis",
+            alias: "hypodorian",
+            maneria: "Protus",
+            type: "plagal",
+            final: 2,
+            tenor: 5,
+            scalePcs: [2, 4, 5, 7, 9, 11, 0],
+            hexachords: ["naturale"],
+            profile: { mood: "sad", phrasing: "lyrical", melodic: "arch", tendency: "neumatic" },
+            cadences: { final: [8, 7, 5], tenor: [0, 5] },
+            modulations: { regular: [2, 5, 7, 9], conceded: [0, 4], initials: [0, 2, 4, 5, 7, 9] },
+            ambitus: { lowest: 0, highest: 17, span: 17 },
+            species: { fifth: [2, 9], fourth: [9, 2] },
+        },
+    ],
+    [
+        3,
+        {
+            mode: 3,
+            nomen: "Deuterus Authenticus",
+            alias: "phrygian",
+            maneria: "Deuterus",
+            type: "authentic",
+            final: 4,
+            tenor: 0,
+            scalePcs: [4, 5, 7, 9, 11, 0, 2],
+            hexachords: ["naturale"],
+            profile: { mood: "mystic", phrasing: "solemn", melodic: "falling", tendency: "melismatic" },
+            cadences: { final: [7, 6, 4], tenor: [0, 4] },
+            modulations: { regular: [4, 0, 7, 9], conceded: [5, 11], initials: [0, 2, 4, 7, 9] },
+            ambitus: { lowest: 4, highest: 16, span: 12 },
+            species: { fifth: [4, 11], fourth: [11, 4] },
+        },
+    ],
+    [
+        4,
+        {
+            mode: 4,
+            nomen: "Deuterus Plagalis",
+            alias: "hypophrygian",
+            maneria: "Deuterus",
+            type: "plagal",
+            final: 4,
+            tenor: 9,
+            scalePcs: [4, 5, 7, 9, 11, 0, 2],
+            hexachords: ["naturale"],
+            profile: { mood: "harmonious", phrasing: "lyrical", melodic: "arch", tendency: "neumatic" },
+            cadences: { final: [7, 6, 4], tenor: [9, 4] },
+            modulations: { regular: [4, 9, 7, 0], conceded: [11], initials: [0, 4, 7, 9] },
+            ambitus: { lowest: 2, highest: 21, span: 19 },
+            species: { fifth: [4, 11], fourth: [11, 4] },
+        },
+    ],
+    [
+        5,
+        {
+            mode: 5,
+            nomen: "Tritus Authenticus",
+            alias: "lydian",
+            maneria: "Tritus",
+            type: "authentic",
+            final: 5,
+            tenor: 0,
+            scalePcs: [5, 7, 9, 11, 0, 2, 4],
+            hexachords: ["molle"],
+            profile: { mood: "happy", phrasing: "solemn", melodic: "rising", tendency: "melismatic" },
+            cadences: { final: [8, 7, 5], tenor: [0, 5] },
+            modulations: { regular: [5, 0, 7, 12], conceded: [9, 2], initials: [5, 7, 9, 0, 12] },
+            ambitus: { lowest: 5, highest: 17, span: 12 },
+            species: { fifth: [5, 0], fourth: [0, 5] },
+        },
+    ],
+    [
+        6,
+        {
+            mode: 6,
+            nomen: "Tritus Plagalis",
+            alias: "hypolydian",
+            maneria: "Tritus",
+            type: "plagal",
+            final: 5,
+            tenor: 9,
+            scalePcs: [5, 7, 9, 11, 0, 2, 4],
+            hexachords: ["molle"],
+            profile: { mood: "devout", phrasing: "lyrical", melodic: "arch", tendency: "neumatic" },
+            cadences: { final: [8, 7, 5], tenor: [9, 5] },
+            modulations: { regular: [5, 9, 0, 7], conceded: [2, 12], initials: [0, 2, 4, 5, 7, 9] },
+            ambitus: { lowest: 3, highest: 21, span: 18 },
+            species: { fifth: [5, 0], fourth: [0, 5] },
+        },
+    ],
+    [
+        7,
+        {
+            mode: 7,
+            nomen: "Tetrardus Authenticus",
+            alias: "mixolydian",
+            maneria: "Tetrardus",
+            type: "authentic",
+            final: 7,
+            tenor: 2,
+            scalePcs: [7, 9, 11, 0, 2, 4, 5],
+            hexachords: ["durum"],
+            profile: { mood: "angelical", phrasing: "solemn", melodic: "rising", tendency: "melismatic" },
+            cadences: { final: [10, 9, 7], tenor: [2, 7] },
+            modulations: { regular: [7, 2, 9, 14], conceded: [5, 0], initials: [7, 9, 11, 2, 14] },
+            ambitus: { lowest: 7, highest: 19, span: 12 },
+            species: { fifth: [7, 2], fourth: [2, 7] },
+        },
+    ],
+    [
+        8,
+        {
+            mode: 8,
+            nomen: "Tetrardus Plagalis",
+            alias: "hypomixolydian",
+            maneria: "Tetrardus",
+            type: "plagal",
+            final: 7,
+            tenor: 0,
+            scalePcs: [7, 9, 11, 0, 2, 4, 5],
+            hexachords: ["durum"],
+            profile: { mood: "perfect", phrasing: "lyrical", melodic: "arch", tendency: "neumatic" },
+            cadences: { final: [10, 9, 7], tenor: [0, 7] },
+            modulations: { regular: [7, 0, 9, 14], conceded: [2, 5], initials: [0, 2, 4, 7, 9, 12, 14] },
+            ambitus: { lowest: 5, highest: 19, span: 14 },
+            species: { fifth: [7, 2], fourth: [2, 7] },
+        },
+    ],
+]);
+//# sourceMappingURL=modes.js.map

package/dist/engines/temper/gabc.d.ts

@@ -0,0 +1,5 @@
+export declare function midiToGabc(midi: number, clef?: string): string;
+export declare function gabcToMidi(letter: string, clef?: string): number;
+export declare function pcToGabc(pc: number, clef?: string, oct?: number): string;
+export declare function gabcToPc(letter: string, clef?: string): number;
+//# sourceMappingURL=gabc.d.ts.map

package/dist/engines/temper/gabc.js

@@ -0,0 +1,53 @@
+// ---------------------------------------------------------------------------
+// engines/temper/gabc — GABC pitch letter utilities
+// ---------------------------------------------------------------------------
+const DIATONIC = [0, 2, 4, 5, 7, 9, 11];
+const LETTERS = "abcdefghijklm";
+const CLEFS = {
+    c1: { doMidi: 60, doIdx: 3 },
+    c2: { doMidi: 60, doIdx: 5 },
+    c3: { doMidi: 60, doIdx: 7 },
+    c4: { doMidi: 60, doIdx: 9 },
+    f3: { doMidi: 53, doIdx: 5 },
+    f4: { doMidi: 53, doIdx: 3 },
+};
+export function midiToGabc(midi, clef = "c4") {
+    const def = CLEFS[clef];
+    if (!def)
+        throw new Error(`Unknown clef: ${clef}`);
+    const octave = Math.floor(midi / 12) - 1;
+    const pc = midi % 12;
+    const diatIdx = DIATONIC.indexOf(pc);
+    if (diatIdx === -1)
+        throw new Error(`MIDI note ${midi} (pc ${pc}) is not diatonic`);
+    const doOctave = Math.floor(def.doMidi / 12) - 1;
+    const staffPos = def.doIdx + diatIdx + (octave - doOctave) * 7;
+    const letter = LETTERS[staffPos];
+    if (!letter)
+        throw new Error(`MIDI ${midi} out of GABC range for clef ${clef}`);
+    return letter;
+}
+export function gabcToMidi(letter, clef = "c4") {
+    const def = CLEFS[clef];
+    if (!def)
+        throw new Error(`Unknown clef: ${clef}`);
+    const staffPos = LETTERS.indexOf(letter.toLowerCase());
+    if (staffPos === -1)
+        throw new Error(`Unknown GABC letter: ${letter}`);
+    const stepsFromDo = staffPos - def.doIdx;
+    const octOffset = Math.floor(stepsFromDo / 7);
+    const diatStep = ((stepsFromDo % 7) + 7) % 7;
+    const doOctave = Math.floor(def.doMidi / 12) - 1;
+    return (doOctave + octOffset + 1) * 12 + DIATONIC[diatStep];
+}
+export function pcToGabc(pc, clef = "c4", oct = 0) {
+    const def = CLEFS[clef];
+    if (!def)
+        throw new Error(`Unknown clef: ${clef}`);
+    const doOctave = Math.floor(def.doMidi / 12) - 1;
+    return midiToGabc((doOctave + oct + 1) * 12 + pc, clef);
+}
+export function gabcToPc(letter, clef = "c4") {
+    return gabcToMidi(letter, clef) % 12;
+}
+//# sourceMappingURL=gabc.js.map

package/dist/engines/temper/gamut.d.ts

@@ -0,0 +1,9 @@
+import type { Pitch } from "./pitch.js";
+import type { Scale } from "./scale.js";
+export type { Pitch };
+export interface GamutOptions {
+    span?: [number, number];
+    chromatic?: boolean;
+}
+export declare function buildGamut(scala: Scale, opts?: GamutOptions): Pitch[];
+//# sourceMappingURL=gamut.d.ts.map

package/dist/engines/temper/gamut.js

@@ -0,0 +1,24 @@
+// ---------------------------------------------------------------------------
+// engines/temper/gamut — modal pitch collection
+// ---------------------------------------------------------------------------
+import { MODES } from "./modes.js";
+import { toPitch } from "./pitch.js";
+export function buildGamut(scala, opts = {}) {
+    const modeData = MODES.get(scala.mode);
+    if (!modeData)
+        throw new RangeError(`Unknown mode: ${scala.mode}. Supported: 1–8.`);
+    const low = opts.span?.[0] ?? modeData.ambitus.lowest + 48;
+    const high = opts.span?.[1] ?? modeData.ambitus.highest + 48;
+    const pcs = opts.chromatic
+        ? new Set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
+        : new Set(modeData.scalePcs);
+    const pitches = [];
+    for (let midi = low; midi <= high; midi++) {
+        const pc = ((midi % 12) + 12) % 12;
+        if (!pcs.has(pc))
+            continue;
+        pitches.push(toPitch(midi, scala));
+    }
+    return pitches;
+}
+//# sourceMappingURL=gamut.js.map

package/dist/engines/temper/guido.d.ts

@@ -0,0 +1,16 @@
+export type { GuidonianVariant, GuidonianEntry } from "./data/guido.js";
+export declare function lookupGuido(midi: number, mode?: number): {
+    name: string | null;
+    nomen: string | null;
+    hexachord: "durum" | "naturale" | "molle" | null;
+    solmization: string | null;
+    mutations: {
+        hexachord: string;
+        solmization: string;
+    }[];
+    hand: {
+        finger: string;
+        region: string;
+    } | null;
+};
+//# sourceMappingURL=guido.d.ts.map

package/dist/engines/temper/guido.js

@@ -0,0 +1,48 @@
+// ---------------------------------------------------------------------------
+// engines/temper/guido — Guidonian hexachord lookups
+// ---------------------------------------------------------------------------
+import { MODES } from "./modes.js";
+import { GUIDONIAN_DATA } from "./data/guido.js";
+// Look up the gamut entry for an exact MIDI number
+function lookupExact(midi) {
+    return GUIDONIAN_DATA.get(midi);
+}
+// Look up by pitch class, picking the entry closest in pitch to the given MIDI
+function lookupByPc(midi) {
+    const pc = ((midi % 12) + 12) % 12;
+    let best;
+    let bestDist = Infinity;
+    for (const [key, entry] of GUIDONIAN_DATA) {
+        if (key % 12 === pc) {
+            const dist = Math.abs(key - midi);
+            if (dist < bestDist) {
+                bestDist = dist;
+                best = entry;
+            }
+        }
+    }
+    return best;
+}
+// ── Public ──
+// Build a Step's guidonian fields for a given MIDI note and optional mode.
+// All fields are always present; nulled when out of gamut or context missing.
+export function lookupGuido(midi, mode) {
+    const entry = lookupExact(midi) ?? lookupByPc(midi);
+    if (!entry) {
+        return { name: null, nomen: null, hexachord: null, solmization: null, mutations: [], hand: null };
+    }
+    // Determine primary hexachord — prefer mode's hexachord if available
+    const modeHex = mode != null ? MODES.get(mode)?.hexachords[0] : undefined;
+    const primary = (modeHex && entry.variants.find((v) => v.hexachord === modeHex)) ??
+        entry.variants.find((v) => v.hexachord === "naturale") ??
+        entry.variants[0];
+    return {
+        name: entry.name[0],
+        nomen: entry.name[1],
+        hexachord: primary?.hexachord ?? null,
+        solmization: primary?.solmization ?? null,
+        mutations: entry.variants.map((v) => ({ hexachord: v.hexachord, solmization: v.solmization })),
+        hand: entry.hand,
+    };
+}
+//# sourceMappingURL=guido.js.map

package/dist/engines/temper/interval.d.ts

@@ -0,0 +1,15 @@
+export type IntervalDirection = "up" | "down" | "unison";
+export type IntervalQuality = "perfect" | "major" | "minor" | "augmented";
+export type Consonance = "perfect" | "imperfect" | "dissonant";
+export interface Interval {
+    nomen: string;
+    alias?: string;
+    quality: IntervalQuality;
+    class: string;
+    direction: IntervalDirection;
+    semitones: number;
+    cents: number;
+    consonance: Consonance;
+}
+export declare function classifyInterval(a: number, b?: number): Interval;
+//# sourceMappingURL=interval.d.ts.map

package/dist/engines/temper/interval.js

@@ -0,0 +1,31 @@
+// ---------------------------------------------------------------------------
+// engines/temper/interval — interval classification between pitches
+// ---------------------------------------------------------------------------
+import { INTERVAL, UNISONUS } from "./data/constants.js";
+const PERFECT_CLASSES = new Set(["P1", "P5", "P8"]);
+const IMPERFECT_CLASSES = new Set(["m3", "M3", "m6", "M6"]);
+function classifyConsonance(intervalClass) {
+    if (PERFECT_CLASSES.has(intervalClass))
+        return "perfect";
+    if (IMPERFECT_CLASSES.has(intervalClass))
+        return "imperfect";
+    return "dissonant";
+}
+export function classifyInterval(a, b) {
+    const semitones = b !== undefined ? b - a : a;
+    const abs = Math.abs(semitones);
+    const simple = abs % 12;
+    const direction = semitones > 0 ? "up" : semitones < 0 ? "down" : "unison";
+    const entry = abs === 0 ? UNISONUS : (simple === 0 ? INTERVAL[0] : INTERVAL[simple]);
+    return {
+        nomen: entry.latin,
+        alias: entry.alias,
+        quality: entry.quality,
+        class: entry.class,
+        direction,
+        semitones,
+        cents: semitones * 100,
+        consonance: classifyConsonance(entry.class),
+    };
+}
+//# sourceMappingURL=interval.js.map

package/dist/engines/temper/modes.d.ts

@@ -0,0 +1,6 @@
+import type { ModeData } from "./data/modes.js";
+export type { ModeProfile, ModeData } from "./data/modes.js";
+export { MODES } from "./data/modes.js";
+/** Return ModeData for mode 1–8. Throws on unknown mode. */
+export declare function getMode(mode: number): ModeData;
+//# sourceMappingURL=modes.d.ts.map

package/dist/engines/temper/modes.js

@@ -0,0 +1,13 @@
+// ---------------------------------------------------------------------------
+// engines/temper/modes — Gregorian modal system
+// ---------------------------------------------------------------------------
+import { MODES } from "./data/modes.js";
+export { MODES } from "./data/modes.js";
+/** Return ModeData for mode 1–8. Throws on unknown mode. */
+export function getMode(mode) {
+    const found = MODES.get(mode);
+    if (!found)
+        throw new Error(`Unknown mode: ${mode}. Supported: 1–8.`);
+    return found;
+}
+//# sourceMappingURL=modes.js.map

package/dist/engines/temper/neume.d.ts

@@ -0,0 +1,14 @@
+import type { Interval } from "./interval.js";
+import type { Pitch, PitchInput } from "./pitch.js";
+import type { Scale } from "./scale.js";
+export type { Interval };
+export type NeumeShape = "punctum" | "pes" | "clivis" | "torculus" | "porrectus" | "scandicus" | "salicus" | "climacus" | "torculus resupinus" | "porrectus flexus" | "scandicus flexus" | "climacus resupinus" | "pes subpunctis" | "compound";
+export interface Neume {
+    pitches: Pitch[];
+    intervals: Interval[];
+    shape: NeumeShape;
+}
+export type Direction = "up" | "down" | "unison";
+export declare function classifyShape(dirs: Direction[]): NeumeShape;
+export declare function buildNeume(inputs: PitchInput[], scala: Scale): Neume;
+//# sourceMappingURL=neume.d.ts.map