tonus 0.1.0

package/dist/engines/score/emitters/musicxml.js

@@ -0,0 +1,166 @@
+// ── XML helpers ──
+function xmlEscape(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function elem(tag, content) {
+    return `<${tag}>${content}</${tag}>`;
+}
+// ── Pitch / accidental from a tabula row ──
+function xmlStep(row) {
+    // spn is e.g. "D4", "Bb3" — the first character is the step letter.
+    return row.spn[0] ?? "C";
+}
+function xmlAccidentalGlyph(row) {
+    // Only an explicitly-marked accidental prints a glyph.
+    if (row.accidentalSource !== "explicit")
+        return null;
+    if (row.accidental === -1)
+        return "flat";
+    if (row.accidental === 1)
+        return "sharp";
+    return "natural";
+}
+const BARLINE_STYLE = {
+    ",": "dashed", "`": "dotted", ";": "normal", ":": "light-light", "::": "light-heavy",
+};
+function computeSyllabic(lyric) {
+    const s = lyric.startsWith("-"), e = lyric.endsWith("-");
+    if (!s && !e)
+        return "single";
+    if (!s && e)
+        return "begin";
+    if (s && e)
+        return "middle";
+    return "end";
+}
+function renderNote(row, flags, ctx) {
+    const lines = [`      <note>`];
+    lines.push(`        <pitch>`);
+    lines.push(`          ${elem("step", xmlStep(row))}`);
+    if (row.accidental !== 0)
+        lines.push(`          ${elem("alter", String(row.accidental))}`);
+    lines.push(`          ${elem("octave", String(row.octave))}`);
+    lines.push(`        </pitch>`);
+    lines.push(`        ${elem("duration", "4")}`);
+    lines.push(`        ${elem("type", "eighth")}`);
+    const glyph = xmlAccidentalGlyph(row);
+    if (glyph)
+        lines.push(`        ${elem("accidental", glyph)}`);
+    if (row.quilisma)
+        lines.push(`        ${elem("notehead", "diamond")}`);
+    const notations = [];
+    // Slurs bind a single neume figure (pes, clivis, torculus …), so a syllable
+    // built of several figures shows one arc per figure.
+    if (flags.slurStart)
+        notations.push(`          <slur type="start" number="1"/>`);
+    if (flags.slurStop)
+        notations.push(`          <slur type="stop" number="1"/>`);
+    if (row.ictus) {
+        notations.push(`          <articulations>`, `            <accent/>`, `          </articulations>`);
+    }
+    const technical = [];
+    if (row.quilisma)
+        technical.push(`            <other-technical>quilisma</other-technical>`);
+    if (row.liquescent)
+        technical.push(`            <other-technical>liquescent</other-technical>`);
+    if (row.strophicus)
+        technical.push(`            <other-technical>strophicus</other-technical>`);
+    if (technical.length) {
+        notations.push(`          <technical>`, ...technical, `          </technical>`);
+    }
+    if (flags.syllableStart && row.neume.type !== "punctum") {
+        notations.push(`          <other-notation type="start">${xmlEscape(row.neume.type)}</other-notation>`);
+    }
+    if (ctx.emitWeights) {
+        notations.push(`          <other-notation type="start">shape:${row.rhythmicShape} index:${row.rhythmicIndex}</other-notation>`);
+    }
+    if (notations.length) {
+        lines.push(`        <notations>`, ...notations, `        </notations>`);
+    }
+    if (flags.syllableStart) {
+        const syllabic = computeSyllabic(row.lyric);
+        const clean = row.lyric.replace(/^-+/, "").replace(/-+$/, "").trim();
+        lines.push(`        <lyric number="1">`, `          ${elem("syllabic", syllabic)}`, `          ${elem("text", xmlEscape(clean))}`, `        </lyric>`);
+    }
+    lines.push(`      </note>`);
+    return lines.join("\n");
+}
+function renderMeasure(rows, measureNumber, isFirst, ctx) {
+    const lines = [`    <measure number="${measureNumber}">`];
+    if (isFirst) {
+        lines.push(`      <attributes>`, `        ${elem("divisions", "8")}`, `        <key>`, `          ${elem("fifths", "0")}`, `        </key>`, `        <time symbol="cut">`, `          ${elem("beats", "4")}`, `          ${elem("beat-type", "4")}`, `        </time>`, `        <clef>`, `          ${elem("sign", "G")}`, `          ${elem("line", "2")}`, `        </clef>`, `      </attributes>`);
+    }
+    // Walk the phrase's rows. The lyric attaches at each syllable start; slurs
+    // bind each neume figure (a syllable may hold several), so they are grouped
+    // by (syllableIndex, neumeGroup) and only drawn when a figure has >1 note.
+    const sameFigure = (a, b) => a.syllableIndex === b.syllableIndex && a.neumeGroup === b.neumeGroup;
+    for (let k = 0; k < rows.length; k++) {
+        const row = rows[k];
+        const prev = rows[k - 1];
+        const next = rows[k + 1];
+        const figureStart = !prev || !sameFigure(prev, row);
+        const figureEnd = !next || !sameFigure(next, row);
+        const figureIsMulti = !(figureStart && figureEnd); // >1 note in this figure
+        const syllableStart = !prev || prev.syllableIndex !== row.syllableIndex;
+        lines.push(renderNote(row, {
+            slurStart: figureIsMulti && figureStart,
+            slurStop: figureIsMulti && figureEnd,
+            syllableStart,
+        }, ctx));
+    }
+    const divisio = rows[rows.length - 1]?.divisio ?? "::";
+    const style = BARLINE_STYLE[divisio] ?? "normal";
+    lines.push(`      <barline location="right">`, `        <bar-style>${style}</bar-style>`, `      </barline>`);
+    lines.push(`    </measure>`);
+    return lines.join("\n");
+}
+function renderScore(rows, chant, ctx) {
+    const parts = [
+        `<?xml version="1.0" encoding="UTF-8"?>`,
+        `<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 4.0 Partwise//EN"`,
+        `  "http://www.musicxml.org/dtds/partwise.dtd">`,
+        `<score-partwise version="4.0">`,
+    ];
+    if (chant.incipit) {
+        parts.push(`  <work>`, `    ${elem("work-title", xmlEscape(chant.incipit))}`, `  </work>`);
+    }
+    parts.push(`  <identification>`);
+    parts.push(`    <encoding>`);
+    parts.push(`      ${elem("software", "tonus")}`, `    </encoding>`, `  </identification>`);
+    for (const text of [
+        chant.mode ? `Mode ${chant.mode}` : null,
+        chant.office,
+    ]) {
+        if (text)
+            parts.push(`  <credit page="1">`, `    ${elem("credit-words", xmlEscape(text))}`, `  </credit>`);
+    }
+    // Group rows into measures by phrase index.
+    const measures = [];
+    let i = 0;
+    let measureNumber = 1;
+    while (i < rows.length) {
+        const phraseIndex = rows[i].phraseIndex;
+        let j = i;
+        while (j < rows.length && rows[j].phraseIndex === phraseIndex)
+            j++;
+        measures.push(renderMeasure(rows.slice(i, j), measureNumber, measureNumber === 1, ctx));
+        measureNumber++;
+        i = j;
+    }
+    parts.push(`  <part-list>`, `    <score-part id="P1">`, `      ${elem("part-name", "Chant")}`, `    </score-part>`, `  </part-list>`, `  <part id="P1">`, ...measures, `  </part>`, `</score-partwise>`);
+    return parts.join("\n");
+}
+/**
+ * Emit a MusicXML 4.0 partwise document from a score's tabula rows plus the
+ * source chant (for titling). Returns `{ xml, diagnostics }`.
+ */
+export function toMusicXML(rows, chant, options = {}) {
+    const diagnostics = [];
+    const ctx = { emitWeights: options.emitWeights ?? false };
+    const xml = rows.length
+        ? renderScore(rows, chant, ctx)
+        : renderScore([], chant, ctx);
+    return { xml, diagnostics };
+}
+//# sourceMappingURL=musicxml.js.map

package/dist/engines/score/infer.d.ts

@@ -0,0 +1,4 @@
+import type { ChantType, Score } from "./types.js";
+export declare function inferChantType(ir: Score): ChantType | undefined;
+export declare function inferMode(ir: Score): number | undefined;
+//# sourceMappingURL=infer.d.ts.map

package/dist/engines/score/infer.js

@@ -0,0 +1,77 @@
+import { OFFICE_LABELS } from "../chant/types.js";
+import { MODES } from "../temper/modes.js";
+const ORDINARY_INCIPITS = [
+    [/^kyrie/i, "ky"],
+    [/^gloria/i, "gl"],
+    [/^etinterra/i, "gl"],
+    [/^credo/i, "cr"],
+    [/^patrem/i, "cr"],
+    [/^sanctus/i, "sa"],
+    [/^agnus/i, "ag"],
+    [/^benedica/i, "be"],
+    [/^ite/i, "it"],
+];
+const OFFICE_CODES = new Set(Object.keys(OFFICE_LABELS));
+export function inferChantType(ir) {
+    const officePart = ir.chant.office?.toLowerCase().trim();
+    if (officePart && OFFICE_CODES.has(officePart))
+        return officePart;
+    const incipit = collectIncipit(ir, 4);
+    if (!incipit)
+        return undefined;
+    for (const [pattern, type] of ORDINARY_INCIPITS) {
+        if (pattern.test(incipit))
+            return type;
+    }
+    return undefined;
+}
+export function inferMode(ir) {
+    const headerMode = parseInt(ir.chant.mode ?? "", 10);
+    if (headerMode >= 1 && headerMode <= 8)
+        return headerMode;
+    const midis = [];
+    for (const phrase of ir.phrases) {
+        for (const syl of phrase.syllables) {
+            for (const note of syl.notes)
+                midis.push(note.pitch.midi);
+        }
+    }
+    if (midis.length === 0)
+        return undefined;
+    const finalisPc = ((midis[midis.length - 1] % 12) + 12) % 12;
+    const candidates = [];
+    for (const [num, data] of MODES) {
+        if (data.final === finalisPc)
+            candidates.push(num);
+    }
+    if (candidates.length === 0)
+        return undefined;
+    if (candidates.length === 1)
+        return candidates[0];
+    // Authentic vs plagal: melody mean above finalis → authentic
+    const finalisStep = midis[midis.length - 1];
+    const mean = midis.reduce((s, v) => s + v, 0) / midis.length;
+    const offset = mean - finalisStep;
+    const authentic = candidates.filter((n) => MODES.get(n)?.type === "authentic");
+    const plagal = candidates.filter((n) => MODES.get(n)?.type === "plagal");
+    if (offset > 3 && authentic.length > 0)
+        return authentic[0];
+    if (offset < -1 && plagal.length > 0)
+        return plagal[0];
+    return (authentic[0] ?? plagal[0]);
+}
+function collectIncipit(ir, maxSyllables) {
+    const parts = [];
+    outer: for (const phrase of ir.phrases) {
+        for (const syl of phrase.syllables) {
+            const text = syl.lyric.replace(/-+$/, "").trim();
+            if (text) {
+                parts.push(text);
+                if (parts.length >= maxSyllables)
+                    break outer;
+            }
+        }
+    }
+    return parts.join("");
+}
+//# sourceMappingURL=infer.js.map

package/dist/engines/score/ir.d.ts

@@ -0,0 +1,4 @@
+import type { Score, ParseResult } from "./types.js";
+import type { Scale } from "../temper/scale.js";
+export declare function buildIR(parsed: ParseResult, chant: Score["chant"], scale: Scale): Score;
+//# sourceMappingURL=ir.d.ts.map

package/dist/engines/score/ir.js

@@ -0,0 +1,177 @@
+import { toPitch } from "../temper/pitch.js";
+import { toStep } from "../temper/step.js";
+import { selectVowel } from "../chant/syllabify.js";
+import { classifyNeume } from "./neume.js";
+function rawToNote(raw, scale) {
+    const midi = raw.step;
+    return {
+        pitch: toPitch(midi, scale),
+        step: toStep(midi, scale),
+        performance: {
+            velocity: 0,
+            duration: raw.duration,
+            rhythmicShape: "arsic",
+            rhythmicIndex: 1,
+        },
+        context: {
+            lyric: raw.lyric,
+            vowel: selectVowel(raw.lyric).vowel,
+            syllableIndex: raw.syllableIndex,
+            neumeGroup: raw.neumeGroup,
+            ictus: raw.ictus,
+            accidentalSource: raw.accidentalSource,
+            quilisma: raw.quilisma,
+            liquescent: raw.liquescent,
+            strophicus: raw.strophicus,
+            doubleEpisema: raw.doubleEpisema,
+            weight: raw.weight,
+        },
+    };
+}
+function makeSyllable(lyric, notes) {
+    return { lyric, notes, neume: classifyNeume(notes) };
+}
+function partitionByIctus(annotated) {
+    const groups = [];
+    let current = [];
+    let currentIctusMidi;
+    const closeGroup = (items, ictusMidi) => {
+        const neumeTypes = new Set();
+        let hasDoubleEpisema = false;
+        for (const a of items) {
+            neumeTypes.add(a.neumeType);
+            if (a.note.context.doubleEpisema)
+                hasDoubleEpisema = true;
+        }
+        return {
+            notes: items.map((a) => a.note),
+            neumeTypes,
+            hasDoubleEpisema,
+            ictusMidi,
+            shape: "arsic",
+        };
+    };
+    for (const a of annotated) {
+        if (a.note.context.ictus) {
+            if (current.length > 0)
+                groups.push(closeGroup(current, currentIctusMidi));
+            current = [a];
+            currentIctusMidi = a.note.pitch.midi;
+        }
+        else {
+            current.push(a);
+        }
+    }
+    if (current.length > 0)
+        groups.push(closeGroup(current, currentIctusMidi));
+    return groups;
+}
+function groupSlope(notes) {
+    if (notes.length < 2)
+        return 0;
+    return notes[notes.length - 1].pitch.midi - notes[0].pitch.midi;
+}
+function classifyGroup(group, prev, apexMidi) {
+    // Conventional overrides: specific neume shapes have fixed rhythmic quality
+    // regardless of melodic context.
+    if (group.neumeTypes.has("salicus"))
+        return "arsic";
+    if (group.hasDoubleEpisema && group.neumeTypes.has("clivis"))
+        return "thetic";
+    const groupIctusMidi = group.ictusMidi ?? group.notes[0].pitch.midi;
+    // Rule 1: incise unity — at or after the apex, everything thetic.
+    if (prev && prev.ictusMidi !== undefined && prev.ictusMidi >= apexMidi) {
+        return "thetic";
+    }
+    // Rule 2: relative ictus pitch.
+    if (prev && prev.ictusMidi !== undefined) {
+        if (groupIctusMidi > prev.ictusMidi)
+            return "arsic";
+        if (groupIctusMidi < prev.ictusMidi)
+            return "thetic";
+    }
+    // Rule 3: neume slope within the group.
+    const slope = groupSlope(group.notes);
+    if (slope > 0)
+        return "arsic";
+    if (slope < 0)
+        return "thetic";
+    // Default: first group of a piece is arsic (Carroll: never begin with thesis).
+    if (!prev)
+        return "arsic";
+    // Tie-breaker: alternate from previous.
+    return prev.shape === "arsic" ? "thetic" : "arsic";
+}
+function classifyCompoundBeats(annotated) {
+    if (annotated.length === 0)
+        return;
+    const groups = partitionByIctus(annotated);
+    // Apex = highest-pitched ictus in the incise.
+    const apexMidi = annotated
+        .filter((a) => a.note.context.ictus)
+        .reduce((max, a) => Math.max(max, a.note.pitch.midi), -Infinity);
+    for (let gi = 0; gi < groups.length; gi++) {
+        const group = groups[gi];
+        const prev = gi > 0 ? groups[gi - 1] : null;
+        group.shape = classifyGroup(group, prev, apexMidi);
+        for (let ni = 0; ni < group.notes.length; ni++) {
+            group.notes[ni].performance.rhythmicShape = group.shape;
+            group.notes[ni].performance.rhythmicIndex = ni + 1;
+        }
+    }
+}
+function applyCompoundBeats(phrases) {
+    for (const phrase of phrases) {
+        const annotated = [];
+        for (const syl of phrase.syllables) {
+            for (const note of syl.notes) {
+                annotated.push({ note, neumeType: syl.neume.type });
+            }
+        }
+        classifyCompoundBeats(annotated);
+    }
+}
+export function buildIR(parsed, chant, scale) {
+    const phrases = [];
+    let currentPhrase = { syllables: [] };
+    let currentNotes = [];
+    let currentLyric = null;
+    for (const event of parsed.events) {
+        if (event.type === "note") {
+            const scored = rawToNote(event, scale);
+            if (currentLyric === null || event.lyric !== currentLyric) {
+                if (currentLyric !== null && currentNotes.length > 0) {
+                    currentPhrase.syllables.push(makeSyllable(currentLyric, currentNotes));
+                }
+                currentLyric = event.lyric;
+                currentNotes = [scored];
+            }
+            else {
+                currentNotes.push(scored);
+            }
+        }
+        else {
+            if (currentLyric !== null && currentNotes.length > 0) {
+                currentPhrase.syllables.push(makeSyllable(currentLyric, currentNotes));
+                currentLyric = null;
+                currentNotes = [];
+            }
+            currentPhrase.divisio = event;
+            phrases.push(currentPhrase);
+            currentPhrase = { syllables: [] };
+        }
+    }
+    if (currentLyric !== null && currentNotes.length > 0) {
+        currentPhrase.syllables.push(makeSyllable(currentLyric, currentNotes));
+    }
+    if (currentPhrase.syllables.length > 0) {
+        phrases.push(currentPhrase);
+    }
+    applyCompoundBeats(phrases);
+    return {
+        chant,
+        phrases,
+        errors: parsed.errors,
+    };
+}
+//# sourceMappingURL=ir.js.map

package/dist/engines/score/meta.d.ts

@@ -0,0 +1,19 @@
+import type { ChantType, Score } from "./types.js";
+export interface ChantMeta {
+    mode: number | null;
+    modeAlias: string | null;
+    family: string | null;
+    type: "authentic" | "plagal" | null;
+    final: number | null;
+    tenor: number | null;
+    molle: boolean;
+    hexachord: "durum" | "naturale" | "molle" | null;
+    office: ChantType | null;
+    incipit: string | null;
+}
+export interface ChantMetaOptions {
+    mode?: number;
+    office?: ChantType;
+}
+export declare function computeMeta(ir: Score, options?: ChantMetaOptions): ChantMeta;
+//# sourceMappingURL=meta.d.ts.map

package/dist/engines/score/meta.js

@@ -0,0 +1,34 @@
+import { MODES } from "../temper/modes.js";
+import { inferChantType, inferMode } from "./infer.js";
+export function computeMeta(ir, options = {}) {
+    const modeNum = options.mode ?? inferMode(ir);
+    const modeData = modeNum !== undefined ? MODES.get(modeNum) : undefined;
+    const office = options.office ?? inferChantType(ir) ?? null;
+    return {
+        mode: modeData?.mode ?? null,
+        modeAlias: modeData?.alias ?? null,
+        family: modeData?.maneria ?? null,
+        type: modeData?.type ?? null,
+        final: modeData?.final ?? null,
+        tenor: modeData?.tenor ?? null,
+        molle: modeData?.hexachords[0] === "molle",
+        hexachord: modeData?.hexachords[0] ?? null,
+        office,
+        incipit: collectIncipit(ir),
+    };
+}
+function collectIncipit(ir, maxSyllables = 6) {
+    const parts = [];
+    outer: for (const phrase of ir.phrases) {
+        for (const syl of phrase.syllables) {
+            const text = syl.lyric.replace(/-+$/, "").trim();
+            if (text) {
+                parts.push(text);
+                if (parts.length >= maxSyllables)
+                    break outer;
+            }
+        }
+    }
+    return parts.length > 0 ? parts.join(" ") : null;
+}
+//# sourceMappingURL=meta.js.map

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

@@ -0,0 +1,3 @@
+import type { Neume, Note } from "./types.js";
+export declare function classifyNeume(notes: Note[]): Neume;
+//# sourceMappingURL=neume.d.ts.map

package/dist/engines/score/neume.js

@@ -0,0 +1,26 @@
+import { classifyShape } from "../temper/neume.js";
+function toDirection(delta) {
+    if (delta > 0)
+        return "up";
+    if (delta < 0)
+        return "down";
+    return "unison";
+}
+export function classifyNeume(notes) {
+    const hasQuilisma = notes.some((n) => n.context.quilisma);
+    const hasLiquescent = notes.some((n) => n.context.liquescent);
+    const hasStrophicus = notes.some((n) => n.context.strophicus);
+    const intervals = [];
+    for (let i = 1; i < notes.length; i++) {
+        intervals.push(notes[i].pitch.midi - notes[i - 1].pitch.midi);
+    }
+    let type = classifyShape(intervals.map(toDirection));
+    // Salicus: three ascending notes with ictus on the middle note (distinguishes
+    // from scandicus, which has no middle ictus). GABC marks it with `'` on the
+    // middle note.
+    if (type === "scandicus" && notes.length === 3 && notes[1].context.ictus) {
+        type = "salicus";
+    }
+    return { type, intervals, hasQuilisma, hasLiquescent, hasStrophicus };
+}
+//# sourceMappingURL=neume.js.map

package/dist/engines/score/parse.d.ts

@@ -0,0 +1,3 @@
+import type { ParseOptions, ParseResult } from "./types.js";
+export declare function parseGABC(gabc: string, options?: ParseOptions): ParseResult;
+//# sourceMappingURL=parse.d.ts.map