tonus 0.8.0 → 0.9.1

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

@@ -30,7 +30,53 @@ const G = {
     noteheadBlack: "E0A4",
     augmentationDot: "E1E7",
     quilisma: "EA20", // medRenQuilismaCMN
+    accidentalFlat: "E260",
+    accidentalNatural: "E261",
+    accidentalSharp: "E262",
 };
+// The staff holds nine written diatonic slots — bottom line E4 to top line F5
+// — which under the transposing gClef8vb sounds E3–F4, MIDI 52–65.
+const STAFF_LO = 52;
+const STAFF_HI = 65;
+/**
+ * How many octaves to lift the written notes so the chant sits on the staff.
+ *
+ * ONE clef, always: moderna draws a gClef8vb and nothing else. What floats is
+ * the written octave, the same move the orreliquum hand already makes when it
+ * lifts a chant by whole octaves onto the gamut's fingers.
+ *
+ * It earns its place going DOWN, which is the direction chant is transposed:
+ * the corpus already sounds below this staff (median 50–62 against 52–65), so
+ * a transposition of −4 puts 43.6% of all notes below the bottom line, some
+ * four ledger lines deep. Choosing the octave takes that to 15.8%. Upward it
+ * changes little, because chant does not sit high to begin with.
+ *
+ * Whole octaves only, and the same lift for the whole chant: shifting by
+ * anything else would respell the music, and shifting per-phrase would make
+ * one page read in two registers.
+ *
+ * The honest limit: an 8vb clef already says "sounds an octave lower", so a
+ * further lift understates the true pitch with nothing on the page confessing
+ * it. That is the accepted cost of keeping one clef; `notatio`'s `spn` remains
+ * the authority on what actually sounds.
+ */
+function pickOctaveLift(rows) {
+    const midis = rows.map((r) => r.midi).filter((m) => typeof m === "number");
+    if (midis.length === 0)
+        return 0;
+    let best = 0;
+    let fewest = Infinity;
+    // Nearest first, so a tie keeps the chant where it was written.
+    for (const lift of [0, 1, -1]) {
+        const shifted = lift * 12;
+        const off = midis.filter((m) => m + shifted < STAFF_LO || m + shifted > STAFF_HI).length;
+        if (off < fewest) {
+            fewest = off;
+            best = lift;
+        }
+    }
+    return best;
+}
 // ── geometry, as a function of the staff ──────────────────────────────────
 //
 // THE CONTRACT (ruled 2026-08-04): `staffHeight` is the height of the STAFF
@@ -114,14 +160,42 @@ export function metrics(staffHeight) {
 }
 const LETTERS = { C: 0, D: 1, E: 2, F: 3, G: 4, A: 5, B: 6 };
 const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-/** Written y for a scientific pitch name on the treble-8 staff (bottom line E4). */
-function writtenY(spn, systemY, gm) {
-    const m = /([A-G])[#b]?(-?\d)/.exec(spn);
+/**
+ * Written y for a scientific pitch name on the treble-8 staff (bottom line
+ * written E4, sounding E3).
+ *
+ * `spn` is a SOUNDING pitch; the gClef8vb this species draws transposes, so the
+ * note is WRITTEN an octave above where it sounds. Hence the `+ 1` below:
+ * sounding G3 is written G4 and sits on the second line, where mode VII's final
+ * belongs. The reference generator folded that lift into a short reference term
+ * (`4 * 7` against a note term carrying `+2`) because it was fed pitches an
+ * octave below today's corpus; the two errors cancelled. Stated once, plainly,
+ * both halves now agree — and the chant lands on the staff instead of a sixth
+ * above it.
+ *
+ * `lift` is the further whole-octave shift `pickOctaveLift` chose for this
+ * chant, so a low or downward-transposed piece is written where it can be read
+ * rather than on a stack of ledger lines.
+ *
+ * The ACCIDENTAL is read but never changes the slot: a flat and its natural
+ * share one line (B-flat sits on the B line), which is why the letter alone
+ * fixes `steps`. It is returned separately so the caller can draw the sign.
+ * Discarding it was a silent wrong pitch — under transposition `Ab3` and `A3`
+ * landed on the same slot with nothing to tell them apart.
+ */
+function writtenY(spn, systemY, gm, lift = 0) {
+    const m = /([A-G])([#b]?)(-?\d)/.exec(spn);
     if (!m)
-        return { y: systemY + gm.MTOP + 4 * gm.MSP, steps: 0 };
-    const di = (Number(m[2]) + 2) * 7 + LETTERS[m[1]];
-    const steps = di - (4 * 7 + LETTERS["E"]); // relative to bottom line E4
-    return { y: systemY + gm.MTOP + 4 * gm.MSP - steps * (gm.MSP / 2), steps };
+        return { y: systemY + gm.MTOP + 4 * gm.MSP, steps: 0, accidental: 0 };
+    const accidental = m[2] === "b" ? -1 : m[2] === "#" ? 1 : 0;
+    const written = Number(m[3]) + 1 + lift; // the 8vb clef writes an octave up
+    const di = (written + 2) * 7 + LETTERS[m[1]];
+    const steps = di - ((4 + 2) * 7 + LETTERS["E"]); // relative to bottom line E4
+    return {
+        y: systemY + gm.MTOP + 4 * gm.MSP - steps * (gm.MSP / 2),
+        steps,
+        accidental,
+    };
 }
 // Moderna's ink, as a CSS custom property with the house default as fallback —
 // the same three properties quadrata emits, so one stylesheet themes both
@@ -172,9 +246,9 @@ const HEAD_K = 0.825;
  *
  * This briefly mapped inclinatum to a half note, on the reasoning that the
  * ambitus figure uses that shape to mark a mode's tenor. That confused a
- * DIAGRAM's private vocabulary with the notation's: an inclinatum is 10.4% of
- * every note in the corpus, so a tenth of every transcribed chant came out
- * hollow, each one implying a length it does not have.
+ * DIAGRAM's private vocabulary with the notation's: an inclinatum is about a
+ * tenth of every note in the corpus, so that share of every transcribed chant
+ * came out hollow, each one implying a length it does not have.
  */
 function notehead(x, y, small, half, gm) {
     const s = gm.SCALE * (small ? 0.68 : 1.0) * HEAD_K;
@@ -229,6 +303,35 @@ function accidentalWidth(code, gm) {
 function accidentalMark(x, y, code, gm) {
     return classedGlyph("accidental", code, x - gm.NH_W / 2 - accidentalWidth(code, gm), y, (gm.SCALE * 0.62));
 }
+/**
+ * The short lines that carry a notehead outside the five, as quadrata's
+ * `ledger` does: one per LINE position the note has passed, not one per step.
+ *
+ * `steps` counts diatonic slots up from the bottom line, so the staff occupies
+ * 0–8 and its lines are the even positions. A note at 10 gets a ledger at 10;
+ * at 11 (a space above that) it still gets only the one at 10. Below, the same
+ * downward: -1 draws nothing, -2 draws at -2.
+ *
+ * Rendered wider than the head by a quarter of its width on each side, the
+ * proportion quadrata uses, so the line reads as staff rather than as a tick.
+ */
+function ledgerLines(steps, mx, systemY, gm) {
+    if (steps >= 0 && steps <= 8)
+        return [];
+    const half = gm.NH_W / 2 + gm.NH_W * 0.25;
+    const out = [];
+    const emit = (lp) => {
+        const ly = systemY + gm.MTOP + 4 * gm.MSP - lp * (gm.MSP / 2);
+        out.push(`<line class="ledger" x1="${(mx - half).toFixed(2)}" y1="${ly.toFixed(2)}" ` +
+            `x2="${(mx + half).toFixed(2)}" y2="${ly.toFixed(2)}" ` +
+            `stroke="${INK}" stroke-width="0.7"/>`);
+    };
+    for (let lp = 10; lp <= steps; lp += 2)
+        emit(lp);
+    for (let lp = -2; lp >= steps; lp -= 2)
+        emit(lp);
+    return out;
+}
 const DIV_KIND = {
     "`": "tick", ",": "tick", ";": "half", ":": "full", "::": "double",
 };
@@ -290,6 +393,17 @@ export function toModerna(rows, chant, options = {}) {
     const markByRow = new Map();
     rows.forEach((row, i) => { const m = marks[i]; if (m)
         markByRow.set(row, m); });
+    // One lift for the whole chant, chosen before any note is placed — a page
+    // that changed register partway would read as two pieces.
+    const lift = pickOctaveLift(rows);
+    // The pitches an engine-computed sign already accounts for. `degreeSpn` is
+    // the mark's own statement of which pitch it alters, so this is the engine
+    // speaking rather than a second guess at its scoping rules — the spelled
+    // path below stays silent wherever a written sign has already spoken.
+    const alteredSpns = new Set();
+    for (const m of marks)
+        if (m?.kind === "glyph" && m.degreeSpn)
+            alteredSpns.add(m.degreeSpn);
     // ── Front matter ── The same official display quadrata sets (title centered
     // over the score, the genus/mode mark stacked at the left margin — the
     // `annotation: "auto"` params), honoured here so both species open a piece
@@ -316,6 +430,10 @@ export function toModerna(rows, chant, options = {}) {
     }
     const body = [];
     const slurs = [];
+    // Ledger lines, collected as the notes are placed but emitted with the STAFF
+    // — they are staff, continuing it for one note, and must lie behind the
+    // notehead rather than cross it. `staff` is joined before `body` below.
+    const ledgers = [];
     const lyricSvgs = [];
     const lyricRuns = [];
     const placements = [];
@@ -415,21 +533,45 @@ export function toModerna(rows, chant, options = {}) {
             const mk = markByRow.get(r);
             if (mk?.kind === "glyph")
                 nx += accidentalWidth(mk.glyph, gm); // room for the accidental
-            const { y, steps } = writtenY(r.spn, systemY, gm);
-            notePos.push({ mx: nx, my: y, steps });
+            const { y, steps, accidental } = writtenY(r.spn, systemY, gm, lift);
+            // A sign the SPELLING demands. `computeAccidentals` speaks for the marks
+            // written in the GABC (`accidentalSource: "explicit"`); a transposed
+            // score carries its accidentals in `spn` alone, where nothing was ever
+            // written, so those would otherwise go undrawn and the note would read a
+            // semitone off with no sign to say so.
+            //
+            // The guard is `alteredSpns`, NOT this row's own `mk`. A written sign is
+            // carried by the note BEFORE the one it governs — on gregobase:1180 the
+            // three signs sit on rows 27/39/62 and their B-flats on 31/40/66, wholly
+            // disjoint — so asking "does this row carry a mark?" says no on the very
+            // note the sign already covers, and drew a second glyph for each.
+            const spelled = accidental !== 0 && !alteredSpns.has(r.spn)
+                ? (accidental === -1 ? G.accidentalFlat : G.accidentalSharp)
+                : null;
+            if (spelled)
+                nx += accidentalWidth(spelled, gm);
+            notePos.push({ mx: nx, my: y, steps, spelled });
             nx += gm.ADV + 4.6 * r.mora;
         }
         const notesW = nx - x - gm.ADV + gm.NH_W / 2 + 2;
         const sylW = Math.max(notesW, textW(lyr));
         // Draw notes.
         srows.forEach((r, i) => {
-            const { mx, my, steps } = notePos[i];
+            const { mx, my, steps, spelled } = notePos[i];
             const onLine = steps % 2 === 0;
+            ledgers.push(...ledgerLines(steps, mx, systemY, gm));
             if (r.quilisma)
                 body.push(quilismaMark(mx, my, gm));
             const mk = markByRow.get(r);
-            if (mk?.kind === "glyph")
-                body.push(accidentalMark(mx, my, mk.glyph, gm));
+            if (mk?.kind === "glyph") {
+                // Vertically the sign belongs to the pitch it alters, not to the note
+                // it was written before; horizontally it stays at this note's column.
+                const ay = mk.degreeSpn ? writtenY(mk.degreeSpn, systemY, gm, lift).y : my;
+                body.push(accidentalMark(mx, ay, mk.glyph, gm));
+            }
+            // A spelled accidental alters THIS note, so it sits on this note's line.
+            else if (spelled)
+                body.push(accidentalMark(mx, my, spelled, gm));
             else if (mk?.kind === "cents") {
                 // Cents labels float in a band above the staff (not glued to the
                 // head) — an analytic overlay, not an engraving mark.
@@ -595,16 +737,22 @@ export function toModerna(rows, chant, options = {}) {
         `width="${W}" height="${height}" class="tonus-chant moderna">${svgTitle}` +
         lyricEmbed +
         header.join("") +
-        staff.join("") + clefSvgs.join("") + body.join("") + slurs.join("") + lyricSvgs.join("") +
+        staff.join("") + ledgers.join("") + clefSvgs.join("") + body.join("") + slurs.join("") + lyricSvgs.join("") +
         `</svg>`;
     const geometry = placements.map((pl) => ({
         phraseIndex: pl.row.phraseIndex,
         syllableIndex: pl.row.syllableIndex,
         neumeGroup: pl.row.neumeGroup,
-        noteIndex: pl.row.neumeIndex,
+        noteIndex: pl.row.noteIndex,
+        neumeIndex: pl.row.neumeIndex,
         system: pl.system,
         x: Number(pl.x.toFixed(2)),
         y: Number(pl.y.toFixed(2)),
+        // Derived, not measured: moderna centres its noteheads on the anchor, so
+        // the ink straddles it evenly. The track mapping above derives them the
+        // same way, from the same number.
+        inkLeft: Number((pl.x - gm.NH_W / 2).toFixed(2)),
+        inkRight: Number((pl.x + gm.NH_W / 2).toFixed(2)),
         systemY: Number(pl.systemY.toFixed(2)),
     }));
     return { svg, geometry };

package/dist/engines/score/emitters/svg.d.ts

@@ -124,13 +124,29 @@ export declare function lyricMarkup(runs: LyricRun[] | undefined, plain: string,
 export interface NoteGeometry {
     phraseIndex: number;
     syllableIndex: number;
+    /** 0-based index of the neume figure within the syllable (GABC break markers). */
     neumeGroup: number;
+    /** 0-based position of this note within its SYLLABLE — the same index
+     *  `ChantTabulaRow.noteIndex` and `Cadence.notes[*][2]` carry, so the three
+     *  address one note. Both emitters used to fill this from `neumeIndex`, which
+     *  agrees only on syllables of a single figure: on *Puer natus est* the
+     *  documented tuple join misaddressed 17 of 159 notes. */
     noteIndex: number;
+    /** 0-based position of this note within its NEUME FIGURE. */
+    neumeIndex: number;
     /** Which system (staff line) the note landed in — 0 when nothing wraps. */
     system: number;
     /** Notehead anchor in svg user units. */
     x: number;
     y: number;
+    /** The figure's measured ink extent. `x` is the ANCHOR — quadrata's square
+     *  glyphs start there and run right, so a span drawn anchor-to-anchor sits
+     *  left of the notes it names and stops short of the last one. A mark that
+     *  spans notes reaches for these instead. Quadrata measures them from the
+     *  glyph's bbox as it places; moderna centres its heads on the anchor, so
+     *  they are derived and straddle it evenly. */
+    inkLeft: number;
+    inkRight: number;
     /** The system's top offset within the svg — 0 in the first system. */
     systemY: number;
 }

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

@@ -492,7 +492,9 @@ export function toSvg(rows, chant, options = {}) {
                 `fill="${r.noteColor}">${esc(mark.label ?? "")}</text>`);
             return 0;
         }
-        const p = placeGlyph(mark.glyph, atX, yFor(row.staffPosition, L, r), r, "accidental", "", r.noteScale * 0.62);
+        // The sign sits on the line of the pitch it alters, which is not this
+        // row's own line where the sign was written before the figure it governs.
+        const p = placeGlyph(mark.glyph, atX, yFor(mark.degree ?? row.staffPosition, L, r), r, "accidental", "", r.noteScale * 0.62);
         if (!p)
             return 0;
         body.push(p.svg);
@@ -736,9 +738,9 @@ export function toSvg(rows, chant, options = {}) {
         // GABC's `z` says "start a new line here", and it is not a hint: an
         // editor who set a chant chose where its lines end, and that choice
         // carries a reading of the piece a width cannot infer. tonus SKIPPED the
-        // token at parse — 41 Graduale chants carry one and every break was
-        // being thrown away, which is why the automatic breaks looked arbitrary
-        // against a printed copy.
+        // token at parse, so every break the Graduale chants that carry one had
+        // set was being thrown away, which is why the automatic breaks looked
+        // arbitrary against a printed copy.
         //
         // It wins over the fit test. Where it is absent the layout still decides.
         if (r.width != null && figure[0].lineBreak && prevSyllable !== -1) {
@@ -831,8 +833,9 @@ export function toSvg(rows, chant, options = {}) {
             // Break when the NEXT phrase will not fit, rather than once this one has
             // already overrun. The check was `x > width - padding`, which only fires
             // AFTER the boundary is crossed — and since a system may break only at a
-            // divisio, the overrun was a whole phrase wide. Measured over thirty
-            // graduals, every one of them overran a 900px request, by up to 289px.
+            // divisio, the overrun was a whole phrase wide. Measured over a sweep of
+            // graduals, every one of them overran the requested width, some by a
+            // wide margin.
             // That is what made a render wider than the column it was drawn for, and
             // why "sometimes bigger, sometimes smaller" varied by chant: the overrun
             // depends on where the phrases happen to fall.
@@ -984,9 +987,9 @@ export function toSvg(rows, chant, options = {}) {
         // above. But it cannot be the only one: quadrata's break test used to live
         // entirely inside `if (div && phraseEnds)`, so a system could end nowhere
         // else, and a phrase wider than the line simply ran until its next barline.
-        // Measured over 120 graduals, a QUARTER of quadrata's lines came out under
-        // 75% full against 6% in moderna — which breaks between syllables. That gap
-        // was the asymmetry, not a spacing difference.
+        // Measured over a sweep of graduals, a QUARTER of quadrata's lines came out
+        // barely more than half full, against a handful in moderna — which breaks
+        // between syllables. That gap was the asymmetry, not a spacing difference.
         //
         // The books break mid-phrase freely; the unit is the word, never a syllable
         // mid-word (which would split a lyric) and never mid-neume. So: at a word
@@ -1217,8 +1220,9 @@ export function toSvg(rows, chant, options = {}) {
             // ...and a word carried to the NEXT system takes a hyphen at the line's
             // end, which is what the books set. The gap-centred rule above cannot
             // reach this case — the two syllables have no gap between them, they have
-            // a line break — so the hyphen was simply dropped: measured, 351 splits
-            // across 165 of 200 graduals rendered with nothing joining the halves.
+            // a line break — so the hyphen was simply dropped: measured, the great
+            // majority of a sweep of graduals rendered a split word with nothing
+            // joining the halves.
             // "Sanc" ended a line and "tus" opened the next, reading as two words.
             const thisRight = ly.cx + estLyricW(ly.text) / 2;
             lyricSvgs.push(lyricText(thisRight + r.lyricSize * 0.42, ly.systemY, "-"));
@@ -1324,10 +1328,13 @@ export function toSvg(rows, chant, options = {}) {
         phraseIndex: pl.row.phraseIndex,
         syllableIndex: pl.row.syllableIndex,
         neumeGroup: pl.row.neumeGroup,
-        noteIndex: pl.row.neumeIndex,
+        noteIndex: pl.row.noteIndex,
+        neumeIndex: pl.row.neumeIndex,
         system: pl.system,
         x: Number(pl.x.toFixed(2)),
         y: Number(pl.y.toFixed(2)),
+        inkLeft: Number(pl.inkLeft.toFixed(2)),
+        inkRight: Number(pl.inkRight.toFixed(2)),
         systemY: Number(pl.systemY.toFixed(2)),
     }));
     return { svg, geometry };

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

@@ -513,7 +513,7 @@ const SHARE_FLOOR = 10;
  */
 function cadenceLabel(fam, mode) {
     // NO CATALOGUE FAMILY IS ITSELF A MEASUREMENT. CADENTIAE holds the families
-    // above a floor of fifty corpus occurrences — 122 of them — so a close that
+    // above a floor of fifty corpus occurrences — 110 of them — so a close that
     // fails to join is not unknown, it is RARER than anything the catalogue
     // records. A third of inked cadences land here, and leaving them bare made
     // the rarest closes look like the ones the analysis had nothing to say
@@ -570,7 +570,7 @@ export function buildTonarium(notes, data, cfg) {
     const governing = (p) => {
         let best = null;
         for (const m of data.modulations) {
-            if (m.confidence >= 0.4 && m.startPhrase <= p && p <= m.endPhrase &&
+            if (m.confidence >= CONF_FLOOR && m.startPhrase <= p && p <= m.endPhrase &&
                 (!best || m.confidence > best.confidence))
                 best = m;
         }
@@ -579,6 +579,18 @@ export function buildTonarium(notes, data, cfg) {
         return home != null ? { mode: home, conf: 1, kind: "home" } : null;
     };
     const systems = [...new Set(notes.map((n) => n.system))].sort((a, b) => a - b);
+    // WHERE EACH CADENCE LANDS. `notes` is in tabula order, so the last note
+    // carrying a cadenceRef is that cadence's closing note, and the system it
+    // sits in is the only one that may draw the closing dot and the label. A
+    // figure that wraps is re-inked in every system it crosses — the claim spans
+    // them — but it CLOSES once. Drawn per-system, a wrapped cadence printed its
+    // landing dot on the earlier fragment's last sample (a landing mid-figure)
+    // and repeated its label, so one close read as two.
+    const landingSystem = new Map();
+    for (const n of notes) {
+        if (n.row.cadenceRef != null)
+            landingSystem.set(n.row.cadenceRef, n.system);
+    }
     for (const s of systems) {
         const sysNotes = notes.filter((n) => n.system === s);
         const sysY = sysNotes[0].systemY;
@@ -676,17 +688,22 @@ export function buildTonarium(notes, data, cfg) {
             const samples = (samplesByPhrase.get(fig[0].row.phraseIndex) ?? [])
                 .filter(([px]) => px >= x0 && px <= x1 + 2 * k);
             // Where the cadence LANDS — the closing dot, which the label centres on.
+            // Only the landing system draws it; an earlier fragment re-inks the
+            // ribbon and stops there.
+            const lands = landingSystem.get(ci) === s;
             let dot;
             if (samples.length >= 2) {
                 const d = ribbonPath(samples, vat, vmax, 1);
                 g.push(`<path d="${d}" fill="${INK}" fill-opacity="${(STRATUM.cadence * op).toFixed(2)}"/>`);
-                const [nx, ny] = samples[samples.length - 1];
-                dot = nx;
-                const r = sc(1.8 * k);
-                g.push(closes
-                    ? `<circle cx="${nx.toFixed(1)}" cy="${ny.toFixed(1)}" r="${r}" fill="${INK}" opacity="${op.toFixed(2)}"/>`
-                    : `<circle cx="${nx.toFixed(1)}" cy="${ny.toFixed(1)}" r="${r}" fill="none" stroke="${INK}" ` +
-                        `stroke-width="${sc(0.9 * k)}" opacity="${op.toFixed(2)}"/>`);
+                if (lands) {
+                    const [nx, ny] = samples[samples.length - 1];
+                    dot = nx;
+                    const r = sc(1.8 * k);
+                    g.push(closes
+                        ? `<circle cx="${nx.toFixed(1)}" cy="${ny.toFixed(1)}" r="${r}" fill="${INK}" opacity="${op.toFixed(2)}"/>`
+                        : `<circle cx="${nx.toFixed(1)}" cy="${ny.toFixed(1)}" r="${r}" fill="none" stroke="${INK}" ` +
+                            `stroke-width="${sc(0.9 * k)}" opacity="${op.toFixed(2)}"/>`);
+                }
             }
             // The label: how characteristic this close is OF THIS CHANT'S MODE —
             // the family's in-mode share over its corpus share ("×2.1"). The raw
@@ -696,7 +713,7 @@ export function buildTonarium(notes, data, cfg) {
             // system's edge it clamps to the margin rather than jumping to the
             // figure's other side. A light end-ticked bracket ties it to the span.
             const lab = cadenceLabel(fam, data.mode);
-            if (lab) {
+            if (lab && lands) {
                 // The label sits UNDER THE CLOSING DOT, centred on it. The dot is
                 // where the cadence lands — the one point the measure is about — so
                 // the number belongs beneath it rather than trailing the figure at
@@ -704,6 +721,8 @@ export function buildTonarium(notes, data, cfg) {
                 // figure's span, which the re-inked sparkline above already draws,
                 // and two marks for one extent read as two claims.
                 const estW = lab.length * 5.6 * k; // 9px mono advance, measured
+                // With fewer than two samples in the landing slice no dot was drawn;
+                // the label centres on the figure's closing ink instead of orphaning.
                 const dotX = dot ?? x1;
                 const left = xL;
                 const right = cfg.rightFor(s) - 2 * k;

package/dist/engines/score/ir.js

@@ -1,7 +1,7 @@
 import { toPitch } from "../temper/pitch.js";
 import { toStep } from "../temper/step.js";
 import { selectVowel } from "../chant/syllabify.js";
-import { classifyNeume } from "./neume.js";
+import { classifyNeume, classifyFigures } from "./neume.js";
 function rawToNote(raw, scale) {
     const midi = raw.step;
     // One read of the lyric: the nucleus and the diphthong it belongs to.
@@ -65,14 +65,15 @@ function rawToNote(raw, scale) {
 const SALICUS_PROLONGATION = 1.3;
 function makeSyllable(lyric, notes) {
     const neume = classifyNeume(notes);
+    const neumes = classifyFigures(notes);
     if (neume.type === "salicus" && notes.length >= 2) {
         const summit = notes[notes.length - 1];
         summit.performance.duration *= SALICUS_PROLONGATION;
     }
     const runs = notes[0]?.context.runs;
     return runs
-        ? { lyric, runs, notes, neume, melisma: notes.length }
-        : { lyric, notes, neume, melisma: notes.length };
+        ? { lyric, runs, notes, neume, neumes, melisma: notes.length }
+        : { lyric, notes, neume, neumes, melisma: notes.length };
 }
 function partitionByIctus(annotated) {
     const groups = [];
@@ -217,8 +218,27 @@ function applyCompoundBeats(phrases) {
     for (const phrase of phrases) {
         const annotated = [];
         for (const syl of phrase.syllables) {
+            // A note is named by ITS OWN figure. Annotating every note of a melisma
+            // with the whole syllable's name told the two conventional overrides
+            // below (salicus → arsic, doubly-dotted clivis → thetic) that a
+            // three-figure syllable was one "compound" neume, so a clivis inside it
+            // was invisible to the rule that names it. The salicus is classified at
+            // syllable scope and so survives the split — see `classifyFigures`.
+            const byGroup = new Map();
+            let figure = -1;
+            let cursor = -1;
             for (const note of syl.notes) {
-                annotated.push({ note, neumeType: syl.neume.type });
+                if (note.context.neumeGroup !== figure) {
+                    figure = note.context.neumeGroup;
+                    cursor++;
+                }
+                byGroup.set(note.context.neumeGroup, syl.neumes[cursor]?.type ?? syl.neume.type);
+            }
+            for (const note of syl.notes) {
+                annotated.push({
+                    note,
+                    neumeType: byGroup.get(note.context.neumeGroup) ?? syl.neume.type,
+                });
             }
         }
         phrase.beats = classifyCompoundBeats(annotated);

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

@@ -1,3 +1,22 @@
 import type { Neume, Note } from "./types.js";
 export declare function classifyNeume(notes: Note[]): Neume;
+/**
+ * The syllable's figures, each classified in its own right.
+ *
+ * GABC marks figure boundaries (`!`, `/`, `//`) and the parser records them as
+ * `context.neumeGroup`, but classification read the whole syllable, so a
+ * three-figure melisma was named once and the name was almost always
+ * "compound" — two of every three compounds the corpus reported. A syllable is
+ * not a neume; it carries neumes.
+ *
+ * THE SALICUS IS CLASSIFIED AT SYLLABLE SCOPE, DELIBERATELY, and the exception
+ * is the point rather than an oversight. Its rule reads the oriscus on the
+ * next-to-last note of an ascent (see `classifyNeume` above), and 41 of the
+ * corpus's 255 salici are written across a figure boundary — the oriscus in
+ * one figure, the summit in the next. Splitting first severed them and the
+ * count fell to 251, which would have narrowed Cardine's definition by
+ * refactoring rather than by ruling. The ascent is the neume; where the
+ * scribe broke the figure is a separate fact.
+ */
+export declare function classifyFigures(notes: Note[]): Neume[];
 //# sourceMappingURL=neume.d.ts.map

package/dist/engines/score/neume.js

@@ -56,4 +56,39 @@ export function classifyNeume(notes) {
     }
     return { type, intervals, hasQuilisma, hasLiquescent, hasStrophicus };
 }
+/**
+ * The syllable's figures, each classified in its own right.
+ *
+ * GABC marks figure boundaries (`!`, `/`, `//`) and the parser records them as
+ * `context.neumeGroup`, but classification read the whole syllable, so a
+ * three-figure melisma was named once and the name was almost always
+ * "compound" — two of every three compounds the corpus reported. A syllable is
+ * not a neume; it carries neumes.
+ *
+ * THE SALICUS IS CLASSIFIED AT SYLLABLE SCOPE, DELIBERATELY, and the exception
+ * is the point rather than an oversight. Its rule reads the oriscus on the
+ * next-to-last note of an ascent (see `classifyNeume` above), and 41 of the
+ * corpus's 255 salici are written across a figure boundary — the oriscus in
+ * one figure, the summit in the next. Splitting first severed them and the
+ * count fell to 251, which would have narrowed Cardine's definition by
+ * refactoring rather than by ruling. The ascent is the neume; where the
+ * scribe broke the figure is a separate fact.
+ */
+export function classifyFigures(notes) {
+    if (notes.length === 0)
+        return [];
+    const whole = classifyNeume(notes);
+    if (whole.type === "salicus")
+        return [whole];
+    const figures = [];
+    let group = -1;
+    for (const note of notes) {
+        if (note.context.neumeGroup !== group) {
+            figures.push([]);
+            group = note.context.neumeGroup;
+        }
+        figures[figures.length - 1].push(note);
+    }
+    return figures.map(classifyNeume);
+}
 //# sourceMappingURL=neume.js.map

package/dist/engines/score/parse.js

@@ -2,8 +2,11 @@ import { buildArticulation } from "./articulation.js";
 import { createLyricDecoder } from "./lyric.js";
 import { detectVowelAccent } from "../chant/syllabify.js";
 // Constants
+// `oct` anchors the staff onto the gamut, which is an absolute frame: guido.ts
+// fixes Γ at midi 43. At oct 3 a chant read an octave below that anchor, so
+// most of the corpus sat at or under the gamut's floor.
 const DEFAULT_OPTIONS = {
-    oct: 3,
+    oct: 4,
     useVowelAccent: true,
 };
 // Per-clef diatonic-step offset. A GABC clef names the staff line it sits on

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

@@ -221,7 +221,13 @@ export interface Syllable {
     /** Styled lyric spans; present only when GABC markup styled this syllable. */
     runs?: LyricRun[];
     notes: Note[];
+    /** The syllable read as ONE figure. A syllable carrying several neumes
+     *  classifies as "compound" here; `neumes` names them individually. */
     neume: Neume;
+    /** The syllable's figures, as GABC groups them (`!`, `/`, `//`), each
+     *  classified in its own right. One entry for a syllable of one figure —
+     *  then `neumes[0]` and `neume` agree. */
+    neumes: Neume[];
     /** Notes sung on this syllable — its melisma. 1 = syllabic, >1 = melismatic. */
     melisma: number;
 }

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

@@ -7,8 +7,10 @@
 // finger to cc before crossing to the middle for dd and ee. Reading it with
 // cc on the middle and dd on the ring makes the line cross three times where
 // the hand turns once. The figure that DRAWS the turn lives in the site
-// (orreliquum-next), and its LOCUS table must agree with the fingers named
-// here; the test that holds the two together lives there beside it. The two b/♮ pairs (58/59, 70/71) share a
+// (orreliquum), and its LOCUS table must agree with the fingers named here;
+// the test that holds the two together lives there beside it.
+//
+// The two b/♮ pairs (58/59, 70/71) share a
 // locus by design — one joint, two readings (fa in molle, mi in durum), the
 // tradition, not a duplication to fix. They are one distinction, named for the
 // two shapes of the letter: b rotundum (the round b) against b quadratum (the

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

@@ -1,3 +1,15 @@
+/**
+ * The GABC letter for a MIDI pitch under `clef` — with `x` appended when the
+ * pitch is a B-flat (`jx`, the flat sign then the note).
+ *
+ * B-flat is the ONE accidental chant sings — the b molle of the medieval gamut,
+ * the whole reason `parse.ts` carries a flat state machine and the `b` clefs
+ * exist. This function used to throw "is not diatonic" on it, which made the
+ * apparent inverse of `gabcToMidi` unable to spell a pitch the parser reads on
+ * every other page. Every other chromatic pitch class still throws: those are
+ * outside the gamut, and inventing a spelling for them would be a worse answer
+ * than refusing.
+ */
 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;