tonus 0.1.8 → 0.5.0

package/dist/engines/score/modulation.js

@@ -1,9 +1,23 @@
 import { computeModalAffinity } from "../temper/modality.js";
+import { MODES } from "../temper/data/modes.js";
 // How much a foreign mode must outscore the home mode (in normalised affinity)
 // before a phrase counts as leaning away. Calibrated against Suñol's worked
 // examples [biblio: sunol-textbook]: at 0.25 the modulations he names in Christus
 // resurgens (to mode 3) register, while incidental colouring below that does not.
 const MARGIN = 0.25;
+// A phrase leaning toward its own mode's authentic/plagal partner is NOT
+// modulating: the partner shares the final, so the "lean" is AMBITUS — the
+// phrase sitting high or low within the same maneria — not a tonal-centre
+// shift. Measured over the corpus: partner leans were 18% of the lean-pairs behind
+// the 28% of moded chants that read as wall-to-wall foreign. A category
+// correction, not a threshold.
+const maneriaPartner = (mode) => mode % 2 === 1 ? mode + 1 : mode - 1; // 1↔2, 3↔4, 5↔6, 7↔8
+// A chant is read as TRANSPOSED (not modulating) when it does not close on its
+// labeled mode's final AND a single foreign mode's spans cover most of its
+// phrases. Corpus context: 81.6% of labeled chants close on their mode's
+// final; of the remainder, the wall-to-wall foreign
+// readings this rule reclassifies were 30% of ALL labeled chants before it.
+const TRANSPOSITION_SHARE = 0.6;
 /** The pitch-class distribution of one phrase's notes (fractions summing to 1). */
 function phrasePcDistribution(phrase) {
     const counts = new Array(12).fill(0);
@@ -38,6 +52,8 @@ export function detectModulations(phrases, homeMode) {
         const top = affinity[0];
         if (!top || top.mode === homeMode)
             return null;
+        if (top.mode === maneriaPartner(homeMode))
+            return null;
         const home = affinity.find((a) => a.mode === homeMode);
         const margin = top.score - (home?.score ?? 0);
         return margin >= MARGIN ? { mode: top.mode, margin } : null;
@@ -54,6 +70,7 @@ export function detectModulations(phrases, homeMode) {
             endPhrase: run.start + run.margins.length - 1,
             toMode: run.mode,
             confidence: Math.min(1, Math.round(avg * 100) / 100),
+            kind: run.margins.length === 1 ? "inflection" : "modulation",
         });
         run = null;
     };
@@ -69,6 +86,38 @@ export function detectModulations(phrases, homeMode) {
         }
     }
     flush();
+    // Transposition, not modulation: the chant does not close on its labeled
+    // final, and one foreign mode's spans dominate its phrases — the displacement
+    // is global (affinal notation, or a label at odds with the notation).
+    const homeFinal = MODES.get(homeMode)?.final;
+    let closingPc;
+    for (let pi = phrases.length - 1; pi >= 0 && closingPc == null; pi--) {
+        for (let si = phrases[pi].syllables.length - 1; si >= 0; si--) {
+            const notes = phrases[pi].syllables[si].notes;
+            if (notes.length > 0) {
+                closingPc = notes[notes.length - 1].pitch.pc;
+                break;
+            }
+        }
+    }
+    if (homeFinal != null && closingPc != null && closingPc !== homeFinal % 12) {
+        const coverage = new Map();
+        for (const m of modulations) {
+            coverage.set(m.toMode, (coverage.get(m.toMode) ?? 0) + (m.endPhrase - m.startPhrase + 1));
+        }
+        // The share is over phrases that SOUND — a note-less phrase (an isolated
+        // divisio, an empty incise) can neither lean nor stay home, so counting it
+        // in the denominator quietly diluted every chant that carried one.
+        const sounding = phrases.filter((p) => !p.syllables.every((s) => s.notes.length === 0)).length;
+        for (const [toMode, phraseCount] of coverage) {
+            if (sounding > 0 && phraseCount / sounding >= TRANSPOSITION_SHARE) {
+                for (const m of modulations) {
+                    if (m.toMode === toMode)
+                        m.kind = "transposition";
+                }
+            }
+        }
+    }
     return modulations;
 }
 //# sourceMappingURL=modulation.js.map

package/dist/engines/score/neume.js

@@ -16,11 +16,42 @@ export function classifyNeume(notes) {
     }
     const dirs = intervals.map(toDirection);
     let type = classifyShape(dirs);
-    // Salicus: an ascending run whose ictus (GABC `'`) marks it apart from a plain
-    // scandicus. The ictus sits on the second-to-last ascending note — the middle
-    // note of a three-note salicus, the penultimate of a longer one (Suñol).
+    // Salicus: "a neume with at least three ascending notes in which the
+    // next-to-last is an oriscus" [biblio: cardine-semiology, ch. 16]. The
+    // ORISCUS is what makes it one — not the editorial ictus.
+    //
+    // RULED 2026-08-04 (Jeffrey): adopt Cardine's definition for DETECTION, not
+    // only for the prolongation. This is a second doctrine call beyond the
+    // original ruling and was ratified on its own terms, because it decides what
+    // the word `salicus` denotes everywhere in tonus — the neume type, the
+    // always-arsic override, the chironomia track, any caller reading
+    // `neume.type`.
+    //
+    // This detection was previously keyed on the Solesmes ictus (GABC `'`) on
+    // the second-to-last note, which is a different thing and a much larger set.
+    // Measured over the sung corpus today: 302 salici against 2,960 scandici, so
+    // the old rule claimed roughly 3,262 groups where 302 are real — and of that
+    // wider set only 9.4% carry an oriscus at all. An ictus-marked ascent with no
+    // oriscus IS a scandicus that Solesmes marked for rhythm; the mark survives
+    // on `context.ictus` for anyone reading it. Bevenot calls the conflation "a
+    // trap" [biblio: cardine-semiology].
+    //
+    // (This paragraph read 2,795 / 36 / 226 until 2026-08-11. Those came from
+    // working/qa-sweep/salicus-before.json, a run over 2,887 chants and 28,498
+    // phrases — a corpus that predates the accidental fix in `parse.ts`, which
+    // was emitting a phantom note at every accidental and inflating every count
+    // downstream. The shape of the finding survived re-measurement; the figures
+    // did not.)
+    //
+    // The LIMIT of this, stated because it is easy to mistake for a bug: tonus
+    // sees only what the transcription marks. Bevenot's own example — the mode-6
+    // Requiem introit's fa-sol-la — carries the Solesmes ictus and NO oriscus in
+    // GregoBase (gregobase:766, on "ae" and "do"), so it reads here as a
+    // scandicus. He is reading the manuscripts; we are reading a printed edition
+    // that resolved the oriscus away. Recovering those needs the MSS, not a rule
+    // change: a guess dressed as a measurement is worse than the gap.
     const allAscending = dirs.length >= 2 && dirs.every((d) => d === "up");
-    if (allAscending && notes[notes.length - 2].context.ictus) {
+    if (allAscending && notes[notes.length - 2].context.oriscus) {
         type = "salicus";
     }
     return { type, intervals, hasQuilisma, hasLiquescent, hasStrophicus };

package/dist/engines/score/parse.js

@@ -1,4 +1,5 @@
 import { buildArticulation } from "./articulation.js";
+import { createLyricDecoder } from "./lyric.js";
 import { detectVowelAccent } from "../chant/syllabify.js";
 // Constants
 const DEFAULT_OPTIONS = {
@@ -45,18 +46,21 @@ function initialAccidentalState(clef) {
         state.set(6, -1); // B-flat key signature
     return state;
 }
+function isLineBreak(token) {
+    // GABC's explicit break: `z` a line break, `Z` a page break, `z0` a break
+    // that suppresses the custos. tonus paginates nothing, so all three mean the
+    // same thing here — end the system.
+    return token === "z" || token === "Z" || token === "z0";
+}
 function isSkippable(token) {
     return (token === " " ||
-        token === "z" ||
-        token === "Z" ||
-        token === "z0" ||
         token === "\r" ||
         token.startsWith("{") ||
         token.includes("+"));
 }
 // parseNeume
 function parseNeume(notation, context) {
-    const { lyric, clef, oct, syllableIndex, accent, accidentalState, profile } = context;
+    const { lyric, runs, keepWithPrev, clef, oct, syllableIndex, accent, accidentalState, pending, profile } = context;
     const weights = profile.weights;
     const ruleGain = profile.ruleGain ?? 1.0;
     const contourScale = profile.contourScale ?? 0.2;
@@ -96,12 +100,15 @@ function parseNeume(notation, context) {
             w += weights.dashWeight; // negative weight
             durWeight += weights.dashDuration;
         }
-        const letter = token[0]?.toLowerCase();
+        const rawLetter = token[0];
+        const letter = rawLetter?.toLowerCase();
         if (!letter)
             return;
         const pitchOffset = letter.charCodeAt(0) - "a".charCodeAt(0);
         if (pitchOffset < 0 || pitchOffset > 12)
             return;
+        // An uppercase pitch letter is a punctum inclinatum (the small diamond).
+        const isInclinatum = rawLetter !== letter;
         const clefOffset = CLEF_OFFSETS.get(clef) ?? 0;
         const pos = pitchOffset - 6 - clefOffset;
         const octave = Math.floor(pos / 7) + oct + 1;
@@ -125,6 +132,29 @@ function parseNeume(notation, context) {
             explicitAccidental = 1;
             accidentalState.set(degree, 1);
         }
+        // An accidental is a MARK, not a note. `fx` says "F is flat from here" and
+        // is drawn as a flat sign on the F line — nothing is sung at that moment.
+        // The state above is its whole effect, so the token ends here.
+        //
+        // It used to fall through and emit a note at the flattened pitch, which is
+        // why `A(fxfg)` returned three notes for two and duplicated the pitch: the
+        // marker sounded, then the F it governs sounded again. 1337 markers across
+        // 426 Graduale chants — 0.97% of every note in the book was a phantom, with
+        // a wrong pitch, inflating counts and inventing an interval of a unison
+        // before each one.
+        //
+        // The token is the mark alone: a bare pitch letter plus x/y/#. A letter
+        // carrying an accidental AND other modifiers is still a real note (nothing
+        // in the corpus writes one, but the reading is the safe one).
+        if (explicitAccidental !== null && /^[a-mA-M][xy#]$/.test(token)) {
+            // The SIGN still belongs on the page — a flat is drawn before the note it
+            // governs, which is where the books put it. The mark had been riding the
+            // phantom note itself; with that gone it is handed to the next real note,
+            // which is both correct notation and what the emitters already expect
+            // (they key the glyph off `accidentalSource === "explicit"`).
+            pending.acc = explicitAccidental;
+            return;
+        }
         // Apply bmolle to B (degree 6 = B natural step 11 → B-flat step 10)
         let step = baseStep;
         if (bmolle && degree === 6)
@@ -137,13 +167,28 @@ function parseNeume(notation, context) {
             step += activeAccidental;
         }
         step += octave * 12;
-        const accidentalSource = explicitAccidental !== null
+        // A sign handed over by a preceding accidental token is drawn AT this note,
+        // whatever its degree. A GABC accidental is a key-signature mark, not an
+        // alteration of the note beside it: `gx` says "G is flat for the rest of the
+        // word" and the books print the flat where it is written, then sing on.
+        // Measured across 693 corpus markers, only 11% are immediately followed by
+        // the same letter — so requiring the degrees to agree (my first attempt)
+        // suppressed the sign in nine cases out of ten.
+        const inheritedSign = pending.acc;
+        if (inheritedSign !== null)
+            pending.acc = null;
+        const inherited = inheritedSign !== null;
+        const accidentalSource = explicitAccidental !== null || inherited
             ? "explicit"
             : accidentalState.has(degree)
                 ? "state"
                 : "none";
-        // Ictus markers (' and _)
-        if (modifiers.includes("'") || modifiers.includes("_")) {
+        // Ictus markers (' and _). Both signal the rhythmic footfall (weight
+        // unchanged), but they are DISTINCT written marks the renderer must draw
+        // apart: ' is the vertical episema (ictus mark), _ the horizontal episema.
+        const hasIctusSign = modifiers.includes("'");
+        const hasEpisema = modifiers.includes("_");
+        if (hasIctusSign || hasEpisema) {
             w += weights.ictusWeight;
             durWeight += weights.ictusDuration;
             ictus = true;
@@ -228,14 +273,43 @@ function parseNeume(notation, context) {
                 prev._weight += weights.repercussionOriscusWeight;
             }
         }
+        // Written note shape (gregorio's S_* vocabulary, simplified) — what the
+        // renderer draws. Priority: the inclinatum diamond and the ornamental
+        // shapes win over the plain punctum/virga forms.
+        let shape = "punctum";
+        if (isInclinatum)
+            shape = "inclinatum";
+        else if (isQuilisma)
+            shape = "quilisma";
+        else if (isStrophicus)
+            shape = "strophicus";
+        else if (modifiers.includes("V"))
+            shape = "virgaReversa";
+        else if (modifiers.includes("v"))
+            shape = "virga";
+        else if (isOriscus)
+            shape = "oriscus";
+        else if (modifiers.includes("r"))
+            shape = "cavum";
+        else if (modifiers.includes("="))
+            shape = "linea";
         intermed.push({
             step,
             degree,
             lyric,
+            runs,
+            keepWithPrev,
             syllableIndex,
             neumeGroup,
+            staffLetter: letter,
+            clef,
+            shape,
             ictus,
+            ictusSign: hasIctusSign,
+            episema: hasEpisema,
             accidental: activeAccidental,
+            ...(inheritedSign !== null ? { accidentalSign: inheritedSign } : {}),
+            ...(explicitAccidental !== null ? { accidentalSign: explicitAccidental } : {}),
             accidentalSource,
             quilisma: isQuilisma,
             liquescent: isLiquescent,
@@ -285,12 +359,24 @@ function parseNeume(notation, context) {
             type: "note",
             step: note.step,
             lyric: note.lyric,
+            runs: note.runs,
+            keepWithPrev: note.keepWithPrev,
             syllableIndex: note.syllableIndex,
             neumeGroup: note.neumeGroup,
+            // Tonic word-accent of this note's syllable (Latin accentuation), the same
+            // boolean the articulation weighting reads above — surfaced as data so the
+            // tabula carries it (accent stats, prose-cursus). Syllable-wide constant.
+            accent,
+            staffLetter: note.staffLetter,
+            clef: note.clef,
+            shape: note.shape,
             ictus: note.ictus,
+            ictusSign: note.ictusSign,
+            episema: note.episema,
             weight,
             duration,
             accidental: note.accidental,
+            ...(note.accidentalSign !== undefined ? { accidentalSign: note.accidentalSign } : {}),
             accidentalSource: note.accidentalSource,
             quilisma: note.quilisma,
             liquescent: note.liquescent,
@@ -316,16 +402,38 @@ export function parseGABC(gabc, options = {}) {
         };
     }
     let currentClef = "c3";
+    // A `z` sets this, and the next note born carries it. The marker usually sits
+    // in its own group — "…son.(c.) (z) Chri(h)ste…" — so the flag has to outlive
+    // the syllable it appeared in rather than being consumed where it was seen.
+    let pendingLineBreak = false;
     let accidentalState = initialAccidentalState(currentClef);
+    // An accidental token draws a sign but sounds nothing, so the sign is claimed
+    // by the next real note. It must survive the syllable boundary: the marker
+    // very often sits ALONE in its own group — "a(gx)b(a)" — so a flag local to
+    // one neume would be discarded before the note it governs is parsed.
+    const pendingAccidental = { acc: null };
+    // One lyric decoder per source: GABC style tags open and close across
+    // syllable (and word) boundaries, so the decode state rides the whole walk.
+    const lyricDecoder = createLyricDecoder();
     const split = source.replace(/\)\s(?=[^\)]*(?:\(|$))/g, ")\n").split(/\n/g);
     split.forEach((word) => {
         if (!word)
             return;
+        // A flat holds for the rest of the WORD or until a divisio — a new word
+        // clears any accidental the previous word set (the clef's own signature
+        // persists). This is the scope the header states, now enforced.
+        accidentalState = initialAccidentalState(currentClef);
+        pendingAccidental.acc = null; // a new clef clears any unclaimed sign
         SYLLABLES_REGEX.lastIndex = 0;
         let match;
         let syllableIndex = 0;
         while ((match = SYLLABLES_REGEX.exec(word)) !== null) {
-            const text = (match[1] ? match[1].trim().split("|")[0] : "") || "";
+            const rawText = (match[1] ? match[1].trim().split("|")[0] : "") || "";
+            // Decode GABC lyric markup EVERY syllable — a style opened here may
+            // close syllables later, so the decoder's state must advance even when
+            // this syllable carries no notes.
+            const decoded = lyricDecoder.decode(rawText);
+            const text = decoded.text;
             const notation = match[2] ? match[2].match(NOTATIONS_REGEX) : null;
             if (!notation || notation.length === 0) {
                 syllableIndex += 1;
@@ -338,6 +446,7 @@ export function parseGABC(gabc, options = {}) {
                 if (CLEF_OFFSETS.has(token)) {
                     currentClef = token;
                     accidentalState = initialAccidentalState(currentClef);
+                    pendingAccidental.acc = null; // a new clef clears any unclaimed sign
                     continue;
                 }
                 if (DIVISIO_DURATIONS.has(token)) {
@@ -345,21 +454,52 @@ export function parseGABC(gabc, options = {}) {
                         divisioToken = token;
                     continue;
                 }
+                // A BREAK IS ITS OWN GROUP. GABC writes one as `(z)`, alone; a `z`
+                // that FOLLOWS notes inside a group is not one. The tokenizer splits
+                // `ra(gz)ti` into ["g","z"] because `z` is not in a note's suffix
+                // class, and that stray token was read as the engraver's break — so
+                // three responsories in the Nocturnale cut their systems a third of
+                // the way across the page and left the rest of the line empty.
+                //
+                // The rule is NOTES BEFORE IT, not "alone in its group": `(z0::c3)` is
+                // a real break carrying the double bar and the new clef after it, and
+                // those are common. What is never a break is a `z` that FOLLOWS
+                // notes, which is what `(gz)` and `(hjHG__z)` are.
+                if (isLineBreak(token)) {
+                    if (noteTokens.length === 0)
+                        pendingLineBreak = true;
+                    continue;
+                }
                 if (isSkippable(token))
                     continue;
                 noteTokens.push(token);
             }
             if (noteTokens.length > 0) {
+                const before = events.length;
                 const accent = opts.useVowelAccent ? detectVowelAccent(text) : false;
                 events.push(...parseNeume(noteTokens, {
                     lyric: text,
+                    runs: decoded.runs,
+                    keepWithPrev: decoded.keepWithPrev,
                     clef: currentClef,
                     oct: opts.oct,
                     syllableIndex,
                     accent,
                     accidentalState,
+                    pending: pendingAccidental,
                     profile: articulation,
                 }));
+                // The break lands on the FIRST note the marker precedes, and is
+                // spent there. A `z` usually sits in a group with NO notes of its
+                // own — "…(::) (z)Ps. E(g)ru…" — so the flag outlives that group
+                // and is claimed by the next note born, which is the one the
+                // engraver meant to start the new line.
+                if (pendingLineBreak) {
+                    const first = events[before];
+                    if (first && first.type === "note")
+                        first.lineBreak = true;
+                    pendingLineBreak = false;
+                }
             }
             if (divisioToken) {
                 events.push({
@@ -368,6 +508,7 @@ export function parseGABC(gabc, options = {}) {
                     duration: DIVISIO_DURATIONS.get(divisioToken) ?? 0.5,
                 });
                 accidentalState = initialAccidentalState(currentClef);
+                pendingAccidental.acc = null; // a new clef clears any unclaimed sign
             }
             syllableIndex += 1;
         }

package/dist/engines/score/phrasing.js

@@ -161,9 +161,10 @@ const TENOR_GAIN = 0.05;
 const TENOR_DISTANCE_DIVISOR = 6;
 const CADENCE_VELOCITY_FACTOR = 0.5;
 const CADENCE_DURATION_FACTOR = 0.6;
-// The phrasing-side reading of the divisio (bar-line) hierarchy. This is the same
-// bar hierarchy tabulated canonically in docs/score.md and weighted for analysis
-// by prosody.ts's cadenceWeight ladder — but here the weights differ on purpose:
+// The phrasing-side reading of the divisio (bar-line) hierarchy. This is the
+// same bar hierarchy tabulated canonically in ../../../docs/api/score.md and
+// weighted for analysis by prosody.ts's cadenceWeight ladder — but here the
+// weights differ on purpose:
 // this is a *shaping* factor, so the virgula (`) gets 0 (a breath, no cadential
 // stress), where the analytic ladder still counts it. Do not unify the three.
 const DIVISIO_STRENGTH = {

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

@@ -18,6 +18,36 @@ export interface RhythmicProfile {
     avgGroupSize: number;
     maxGroupSize: number;
 }
+/** Melodic-motion statistics over adjacent notes (within a phrase). */
+export interface IntervalStats {
+    /** Signed semitone interval → count. Movement across a divisio is excluded. */
+    histogram: Record<number, number>;
+    /** Largest absolute interval, in semitones. */
+    maxLeap: number;
+    /** Fraction of motions that are leaps (≥ a fourth, 5+ semitones). */
+    leapRate: number;
+    /** Motion by class: step (1–2 st), skip (a third, 3–4), leap (a fourth+, 5+). */
+    motus: {
+        step: number;
+        skip: number;
+        leap: number;
+    };
+}
+/** The melodic arch of the piece: where it begins, peaks, and ends, and its shape. */
+export interface Arcus {
+    /** First note's MIDI. */
+    initial: number;
+    /** Highest note's MIDI. */
+    peak: number;
+    /** Last note's MIDI. */
+    final: number;
+    /**
+     * Signed arch index: how much the melody rises to its peak versus where it
+     * settles. +1 a full arch (rises high, returns low), 0 flat/monotonic,
+     * negative when it ends above where it began relative to the climb.
+     */
+    archIndex: number;
+}
 export interface Prosody {
     noteCount: number;
     syllableCount: number;
@@ -26,6 +56,14 @@ export interface Prosody {
     ambitus: number | null;
     melismaRatio: number;
     melismaByPhrase: number[];
+    /** Mean notes-per-syllable of each phrase's FINAL syllable — the cadential melisma. */
+    melismaCadential: number;
+    /** Mean pitch minus the final note, in semitones — how high the melody sits above its rest. */
+    tessitura: number | null;
+    /** Melodic-interval statistics over adjacent within-phrase notes. */
+    intervals: IntervalStats;
+    /** The melodic arch: initial/peak/final and a signed arch index. */
+    arcus: Arcus | null;
     ictusRate: number;
     rhythmicProfile: RhythmicProfile;
     cadenceWeight: number;

package/dist/engines/score/prosody.js

@@ -16,6 +16,18 @@ export function computeProsody(phrases) {
     };
     let cadenceWeight = 0;
     const melismaByPhrase = [];
+    // Interval statistics — adjacent notes WITHIN a phrase; prevMidi resets to null
+    // at each phrase so a breath across a divisio is not counted as a leap.
+    const histogram = {};
+    let motions = 0, stepCount = 0, skipCount = 0, leapCount = 0, maxLeap = 0;
+    let prevMidi = null;
+    // Tessitura + arch: running MIDI sum, the first note, the peak, the last note.
+    let midiSum = 0;
+    let firstMidi = null;
+    let lastMidi = 0;
+    let peakMidi = -Infinity;
+    // Cadential melisma — the note count of each phrase's final sung syllable.
+    const cadentialMelismas = [];
     const closeGroup = () => {
         if (currentGroupSize > 0) {
             groupSizes.push(currentGroupSize);
@@ -27,24 +39,51 @@ export function computeProsody(phrases) {
         phraseCount++;
         let phraseNotes = 0;
         let phraseSyllables = 0;
+        let lastSylNotes = 0; // notes on this phrase's most recent sung syllable
+        prevMidi = null; // intervals never cross a phrase boundary (a breath)
         for (const syl of phrase.syllables) {
             if (syl.notes.length === 0)
                 continue;
             phraseSyllables++;
             syllableCount++;
+            lastSylNotes = syl.notes.length;
             for (const note of syl.notes) {
+                const midi = note.pitch.midi;
                 noteCount++;
                 phraseNotes++;
-                if (note.pitch.midi < minMidi)
-                    minMidi = note.pitch.midi;
-                if (note.pitch.midi > maxMidi)
-                    maxMidi = note.pitch.midi;
+                if (midi < minMidi)
+                    minMidi = midi;
+                if (midi > maxMidi)
+                    maxMidi = midi;
                 if (note.context.ictus)
                     ictusCount++;
                 if (note.performance.rhythmicShape === "arsic")
                     arsicCount++;
                 else
                     theticCount++;
+                // Tessitura + arch running values.
+                midiSum += midi;
+                if (firstMidi === null)
+                    firstMidi = midi;
+                if (midi > peakMidi)
+                    peakMidi = midi;
+                lastMidi = midi;
+                // Adjacent-note interval, within the phrase only.
+                if (prevMidi !== null) {
+                    const iv = midi - prevMidi;
+                    histogram[iv] = (histogram[iv] ?? 0) + 1;
+                    const abs = Math.abs(iv);
+                    motions++;
+                    if (abs > maxLeap)
+                        maxLeap = abs;
+                    if (abs <= 2)
+                        stepCount++;
+                    else if (abs <= 4)
+                        skipCount++;
+                    else
+                        leapCount++;
+                }
+                prevMidi = midi;
                 if (note.performance.rhythmicIndex === 1) {
                     closeGroup();
                     currentGroupSize = 1;
@@ -54,10 +93,12 @@ export function computeProsody(phrases) {
                 }
             }
         }
+        if (phraseSyllables > 0)
+            cadentialMelismas.push(lastSylNotes);
         if (phrase.divisio) {
             // Analytic bar-importance weights, one rung per divisio in the bar-line
-            // hierarchy (the canonical table is in docs/score.md). These are a
-            // MEASUREMENT — every divisio counts, including the virgula (`) — distinct
+            // hierarchy (the canonical table is in ../../../docs/api/score.md).
+            // These are a MEASUREMENT — every divisio counts, including the virgula (`) — distinct
             // from phrasing.ts's DIVISIO_STRENGTH, which zeroes the virgula because it
             // is a shaping factor, not a count.
             const d = phrase.divisio.divisio;
@@ -92,6 +133,25 @@ export function computeProsody(phrases) {
     const avgGroupSize = groupSizes.length > 0
         ? groupSizes.reduce((s, n) => s + n, 0) / groupSizes.length
         : 0;
+    // Tessitura: mean height above the resting (final) note, in semitones.
+    const tessitura = noteCount > 0 ? midiSum / noteCount - lastMidi : null;
+    // Arch: the climb to the peak vs. the descent to the close, normalized by the
+    // total climb so a full rise-and-return reads ~+1 and a monotone rise reads ~0.
+    let arcus = null;
+    if (firstMidi !== null) {
+        const climb = peakMidi - firstMidi;
+        const archIndex = climb > 0 ? (peakMidi - lastMidi) / climb : 0;
+        arcus = { initial: firstMidi, peak: peakMidi, final: lastMidi, archIndex };
+    }
+    const intervals = {
+        histogram,
+        maxLeap,
+        leapRate: motions > 0 ? leapCount / motions : 0,
+        motus: { step: stepCount, skip: skipCount, leap: leapCount },
+    };
+    const melismaCadential = cadentialMelismas.length > 0
+        ? cadentialMelismas.reduce((s, n) => s + n, 0) / cadentialMelismas.length
+        : 0;
     return {
         phraseCount,
         noteCount,
@@ -100,6 +160,10 @@ export function computeProsody(phrases) {
         ambitus: noteRange?.span ?? null,
         melismaRatio: syllableCount > 0 ? noteCount / syllableCount : 0,
         melismaByPhrase,
+        melismaCadential,
+        tessitura,
+        intervals,
+        arcus,
         ictusRate: noteCount > 0 ? ictusCount / noteCount : 0,
         rhythmicProfile: {
             arsic: arsicCount,